jpmschweitzer/clide
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

keep the clide.dart barrel Flutter-free

Browse Source 
`lib/kernel/src/toolchain.dart` is a `ChangeNotifier`, so it pulls in
`package:flutter/foundation.dart`. `GitClient` and `PqlClient` imported
it for the resolved binary paths, which leaked Flutter through the
`package:clide/clide.dart` barrel — breaking `dart test` on every core
subsystem suite (`ci/test_core.sh`), since pure Dart can't compile
Flutter packages.

Split the Flutter-free pieces into `toolchain_paths.dart`: `ResolvedPaths`,
`resolveToolchainPaths`, and a new read-only `ToolchainView` interface
with a `ToolchainView.resolved()` const factory. `Toolchain` now
implements `ToolchainView`; the clients depend on the interface. Core
test setups that built a `Toolchain` just to call `applyResolved`
switch to the factory.

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
jpmschweitzer
2026-05-14 21:21:09 +02:00
co-authored by Claude
parent a3a10cddf3
commit 5cad98224f
10 changed files with 172 additions and 170 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/kernel/src/toolchain.dart
+18 -140
View File
@@ -3,31 +3,21 @@
/// Resolution runs in a background isolate via [Toolchain.resolvePaths]
/// to avoid blocking the merged UI/platform thread on macOS. The result
/// is applied on the main thread via [Toolchain.applyResolved].
///
/// The Flutter-free data types ([ResolvedPaths], [ToolchainView]) and
/// the isolate-side resolver ([resolveToolchainPaths]) live in
/// `toolchain_paths.dart` and are re-exported here for convenience.
library;
import 'dart:async';
import 'dart:io';
import 'package:flutter/foundation.dart';
/// Serializable result of tool resolution (crosses isolate boundary).
class ResolvedPaths {
const ResolvedPaths({
this.git,
this.pql,
this.tmux,
this.shell,
this.gitEnv,
});
import 'toolchain_paths.dart';
final String? git;
final String? pql;
final String? tmux;
final String? shell;
final Map<String, String>? gitEnv;
}
export 'toolchain_paths.dart';
class Toolchain extends ChangeNotifier {
class Toolchain extends ChangeNotifier implements ToolchainView {
String? _git;
String? _pql;
String? _tmux;
@@ -35,17 +25,25 @@ class Toolchain extends ChangeNotifier {
Map<String, String>? _gitEnv;
bool _resolved = false;
@override
String get git => _git ?? 'git';
@override
String get pql => _pql ?? 'pql';
@override
String get tmux => _tmux ?? 'tmux';
@override
String get shell => _shell ?? '/bin/bash';
/// Extra environment variables for git (e.g. GIT_EXEC_PATH for dugite).
@override
Map<String, String>? get gitEnv => _gitEnv;
@override
bool get resolved => _resolved;
@override
bool get allOk => _resolved && missing.isEmpty;
@override
List<String> get missing => [
if (_git == null) 'git',
if (_pql == null) 'pql',
@@ -79,127 +77,7 @@ class Toolchain extends ChangeNotifier {
}
/// Pure function — runs in a background isolate. All file I/O happens
/// here, off the main thread.
static ResolvedPaths resolvePaths({required String workspaceRoot}) {
final dugite = '$workspaceRoot/native/dugite/bin';
String? git;
Map<String, String>? gitEnv;
final dugiteGit = _firstExisting(['$dugite/git']);
if (dugiteGit != null) {
git = dugiteGit;
final dugiteRoot = File(dugiteGit).parent.parent.path;
gitEnv = {
'GIT_EXEC_PATH': '$dugiteRoot/libexec/git-core',
'GIT_TEMPLATE_DIR': '$dugiteRoot/share/git-core/templates',
};
} else {
git = _findOnPath('git');
}
final pql = _findOnPath('pql');
final tmux = _findOnPath('tmux');
final shell = _findOnPath(Platform.environment['SHELL']?.split('/').last ?? 'bash');
return ResolvedPaths(
git: git,
pql: pql,
tmux: tmux,
shell: shell,
gitEnv: gitEnv,
);
}
static String? _findOnPath(String name) {
for (final dir in _expandedPath().split(':')) {
if (dir.isEmpty) continue;
final f = File('$dir/$name');
if (f.existsSync()) return f.path;
}
return null;
}
/// Build expanded PATH inline — must be self-contained for isolate use.
static String _expandedPath() {
final base = Platform.environment['PATH'] ?? '';
if (!Platform.isMacOS) return base;
final home = Platform.environment['HOME'] ?? '';
final extras = <String>[
if (home.isNotEmpty) '$home/.local/bin',
'/opt/homebrew/bin',
'/opt/homebrew/sbin',
'/usr/local/bin',
];
final existing = base.split(':').toSet();
final missing = extras.where((p) => !existing.contains(p));
if (missing.isEmpty) return base;
return [...missing, ...existing].join(':');
}
static String? _firstExisting(List<String> candidates) {
for (final c in candidates) {
if (File(c).existsSync()) return c;
}
return null;
}
}
/// Top-level function for compute/isolate use. Takes a single String
/// argument (the workspace root) and returns a plain-data result.
ResolvedPaths resolveToolchainPaths(String workspaceRoot) {
final dugite = '$workspaceRoot/native/dugite/bin';
String? git;
Map<String, String>? gitEnv;
final dugiteGit = _firstExistingStandalone(['$dugite/git']);
if (dugiteGit != null) {
git = dugiteGit;
final dugiteRoot = File(dugiteGit).parent.parent.path;
gitEnv = {
'GIT_EXEC_PATH': '$dugiteRoot/libexec/git-core',
'GIT_TEMPLATE_DIR': '$dugiteRoot/share/git-core/templates',
};
} else {
git = _findOnPathStandalone('git');
}
return ResolvedPaths(
git: git,
pql: _findOnPathStandalone('pql'),
tmux: _findOnPathStandalone('tmux'),
shell: _findOnPathStandalone(Platform.environment['SHELL']?.split('/').last ?? 'bash'),
gitEnv: gitEnv,
);
}
String? _findOnPathStandalone(String name) {
for (final dir in _expandedPathStandalone().split(':')) {
if (dir.isEmpty) continue;
final f = File('$dir/$name');
if (f.existsSync()) return f.path;
}
return null;
}
String? _firstExistingStandalone(List<String> candidates) {
for (final c in candidates) {
if (File(c).existsSync()) return c;
}
return null;
}
String _expandedPathStandalone() {
final base = Platform.environment['PATH'] ?? '';
if (!Platform.isMacOS) return base;
final home = Platform.environment['HOME'] ?? '';
final extras = <String>[
if (home.isNotEmpty) '$home/.local/bin',
'/opt/homebrew/bin',
'/opt/homebrew/sbin',
'/usr/local/bin',
];
final existing = base.split(':').toSet();
final missing = extras.where((p) => !existing.contains(p));
if (missing.isEmpty) return base;
return [...missing, ...existing].join(':');
/// here, off the main thread. Delegates to the Flutter-free
/// [resolveToolchainPaths].
static ResolvedPaths resolvePaths({required String workspaceRoot}) => resolveToolchainPaths(workspaceRoot);
}
lib/kernel/src/toolchain_paths.dart
+135
View File
@@ -0,0 +1,135 @@
/// Flutter-free toolchain data + resolution.
///
/// Split out of `toolchain.dart` so that pure-Dart consumers (the IPC
/// subsystems exported through `package:clide/clide.dart`, e.g.
/// [GitClient] and [PqlClient]) don't transitively pull in
/// `package:flutter/foundation.dart`. The live, listenable `Toolchain`
/// stays in `toolchain.dart`; everything here is plain Dart and runs
/// fine under `dart test`.
library;
import 'dart:io';
/// Serializable result of tool resolution (crosses isolate boundary).
class ResolvedPaths {
const ResolvedPaths({
this.git,
this.pql,
this.tmux,
this.shell,
this.gitEnv,
});
final String? git;
final String? pql;
final String? tmux;
final String? shell;
final Map<String, String>? gitEnv;
}
/// Read-only view of resolved tool paths. The concrete `Toolchain`
/// (in `toolchain.dart`) implements this on top of `ChangeNotifier`;
/// pure-Dart clients depend on the interface so they stay Flutter-free.
abstract class ToolchainView {
/// A fixed, already-resolved view over [paths]. Flutter-free — handy
/// for tests and isolate-side code that has a [ResolvedPaths] but no
/// need for the listenable `Toolchain`.
const factory ToolchainView.resolved(ResolvedPaths paths) = _StaticToolchain;
String get git;
String get pql;
String get tmux;
String get shell;
Map<String, String>? get gitEnv;
bool get resolved;
bool get allOk;
List<String> get missing;
}
class _StaticToolchain implements ToolchainView {
const _StaticToolchain(this._paths);
final ResolvedPaths _paths;
@override
String get git => _paths.git ?? 'git';
@override
String get pql => _paths.pql ?? 'pql';
@override
String get tmux => _paths.tmux ?? 'tmux';
@override
String get shell => _paths.shell ?? '/bin/bash';
@override
Map<String, String>? get gitEnv => _paths.gitEnv;
@override
bool get resolved => true;
@override
bool get allOk => missing.isEmpty;
@override
List<String> get missing => [
if (_paths.git == null) 'git',
if (_paths.pql == null) 'pql',
if (_paths.tmux == null) 'tmux',
];
}
/// Top-level function for compute/isolate use. Takes a single String
/// argument (the workspace root) and returns a plain-data result.
ResolvedPaths resolveToolchainPaths(String workspaceRoot) {
final dugite = '$workspaceRoot/native/dugite/bin';
String? git;
Map<String, String>? gitEnv;
final dugiteGit = _firstExisting(['$dugite/git']);
if (dugiteGit != null) {
git = dugiteGit;
final dugiteRoot = File(dugiteGit).parent.parent.path;
gitEnv = {
'GIT_EXEC_PATH': '$dugiteRoot/libexec/git-core',
'GIT_TEMPLATE_DIR': '$dugiteRoot/share/git-core/templates',
};
} else {
git = _findOnPath('git');
}
return ResolvedPaths(
git: git,
pql: _findOnPath('pql'),
tmux: _findOnPath('tmux'),
shell: _findOnPath(Platform.environment['SHELL']?.split('/').last ?? 'bash'),
gitEnv: gitEnv,
);
}
String? _findOnPath(String name) {
for (final dir in _expandedPath().split(':')) {
if (dir.isEmpty) continue;
final f = File('$dir/$name');
if (f.existsSync()) return f.path;
}
return null;
}
String? _firstExisting(List<String> candidates) {
for (final c in candidates) {
if (File(c).existsSync()) return c;
}
return null;
}
/// Build expanded PATH inline — must be self-contained for isolate use.
String _expandedPath() {
final base = Platform.environment['PATH'] ?? '';
if (!Platform.isMacOS) return base;
final home = Platform.environment['HOME'] ?? '';
final extras = <String>[
if (home.isNotEmpty) '$home/.local/bin',
'/opt/homebrew/bin',
'/opt/homebrew/sbin',
'/usr/local/bin',
];
final existing = base.split(':').toSet();
final missing = extras.where((p) => !existing.contains(p));
if (missing.isEmpty) return base;
return [...missing, ...existing].join(':');
}
lib/src/git/client.dart
+3 -3
View File
@@ -1,4 +1,4 @@
/// Typed git client backed by [Toolchain].
/// Typed git client backed by a [ToolchainView].
///
/// Every subprocess call goes through [_run] which uses the resolved
/// absolute binary path from the toolchain. Parsing is delegated to
@@ -7,7 +7,7 @@ library;
import 'dart:io';
import '../../kernel/src/toolchain.dart';
import '../../kernel/src/toolchain_paths.dart';
import 'diff.dart' show GitDiff, parseDiffOutput;
import 'operations.dart' show GitException, GitLogEntry;
import 'status.dart';
@@ -15,7 +15,7 @@ import 'status.dart';
class GitClient {
GitClient({required this.toolchain, required this.workDir});
final Toolchain toolchain;
final ToolchainView toolchain;
final Directory workDir;
// -- queries --------------------------------------------------------------
lib/src/pql/client.dart
+2 -2
View File
@@ -8,7 +8,7 @@ library;
import 'dart:convert';
import 'dart:io';
import '../../kernel/src/toolchain.dart';
import '../../kernel/src/toolchain_paths.dart';
class PqlException implements Exception {
const PqlException(this.message, {this.exitCode = 1, this.stderr = ''});
@@ -24,7 +24,7 @@ class PqlClient {
PqlClient({required this.workDir, required this.toolchain});
final Directory workDir;
final Toolchain toolchain;
final ToolchainView toolchain;
Future<List<Map<String, Object?>>> files({String? glob, int? limit}) async {
final args = ['files'];
test/daemon/git_commands_errors_test.dart
+2 -3
View File
@@ -8,7 +8,7 @@ library;
import 'dart:io';
import 'package:clide/clide.dart';
import 'package:clide/kernel/src/toolchain.dart';
import 'package:clide/kernel/src/toolchain_paths.dart';
import 'package:clide/src/daemon/git_commands.dart';
import 'package:test/test.dart';
@@ -18,8 +18,7 @@ void main() {
setUp(() async {
sandbox = await Directory.systemTemp.createTemp('clide-git-cmd-err-');
final toolchain = Toolchain();
toolchain.applyResolved(const ResolvedPaths(git: '/tmp/clide-no-such-git-binary'));
final toolchain = ToolchainView.resolved(const ResolvedPaths(git: '/tmp/clide-no-such-git-binary'));
final git = GitClient(toolchain: toolchain, workDir: sandbox);
dispatcher = DaemonDispatcher();
final sink = RecordingEventSink();
test/daemon/git_commands_test.dart
+2 -3
View File
@@ -1,7 +1,7 @@
import 'dart:io';
import 'package:clide/clide.dart';
import 'package:clide/kernel/src/toolchain.dart';
import 'package:clide/kernel/src/toolchain_paths.dart';
import 'package:clide/src/daemon/git_commands.dart';
import 'package:test/test.dart';
@@ -33,8 +33,7 @@ void main() {
sink = RecordingEventSink();
dispatcher = DaemonDispatcher();
final toolchain = Toolchain();
toolchain.applyResolved(Toolchain.resolvePaths(workspaceRoot: sandbox.path));
final toolchain = ToolchainView.resolved(resolveToolchainPaths(sandbox.path));
final gitClient = GitClient(toolchain: toolchain, workDir: sandbox);
registerGitCommands(dispatcher, gitClient, sink);
});
test/daemon/pql_commands_errors_test.dart
+2 -3
View File
@@ -8,7 +8,7 @@ library;
import 'dart:io';
import 'package:clide/clide.dart';
import 'package:clide/kernel/src/toolchain.dart';
import 'package:clide/kernel/src/toolchain_paths.dart';
import 'package:clide/src/daemon/pql_commands.dart';
import 'package:clide/src/pql/client.dart';
import 'package:test/test.dart';
@@ -17,8 +17,7 @@ void main() {
late DaemonDispatcher dispatcher;
setUp(() {
final toolchain = Toolchain();
toolchain.applyResolved(const ResolvedPaths(pql: '/tmp/clide-no-such-pql-binary'));
final toolchain = ToolchainView.resolved(const ResolvedPaths(pql: '/tmp/clide-no-such-pql-binary'));
final pql = PqlClient(workDir: Directory.current, toolchain: toolchain);
dispatcher = DaemonDispatcher();
registerPqlCommands(dispatcher, pql);
test/daemon/pql_commands_test.dart
+2 -3
View File
@@ -1,7 +1,7 @@
import 'dart:io';
import 'package:clide/clide.dart';
import 'package:clide/kernel/src/toolchain.dart';
import 'package:clide/kernel/src/toolchain_paths.dart';
import 'package:clide/src/daemon/pql_commands.dart';
import 'package:test/test.dart';
@@ -10,8 +10,7 @@ void main() {
late PqlClient pql;
setUp(() {
final toolchain = Toolchain();
toolchain.applyResolved(Toolchain.resolvePaths(workspaceRoot: Directory.current.path));
final toolchain = ToolchainView.resolved(resolveToolchainPaths(Directory.current.path));
pql = PqlClient(workDir: Directory.current, toolchain: toolchain);
dispatcher = DaemonDispatcher();
registerPqlCommands(dispatcher, pql);
test/git/client_test.dart
+3 -8
View File
@@ -5,16 +5,12 @@ library;
import 'dart:io';
import 'package:clide/kernel/src/toolchain.dart';
import 'package:clide/kernel/src/toolchain_paths.dart';
import 'package:clide/src/git/client.dart';
import 'package:clide/src/git/operations.dart' show GitException;
import 'package:test/test.dart';
Toolchain _toolchain() {
final t = Toolchain();
t.applyResolved(Toolchain.resolvePaths(workspaceRoot: Directory.current.path));
return t;
}
ToolchainView _toolchain() => ToolchainView.resolved(resolveToolchainPaths(Directory.current.path));
Future<Directory> _newRepo({String filename = 'file.txt', String contents = 'hello\n'}) async {
final dir = await Directory.systemTemp.createTemp('clide-git-client-');
@@ -195,8 +191,7 @@ void main() {
group('GitClient — error surface', () {
test('a bad git binary path makes _run throw GitException', () async {
final t = Toolchain();
t.applyResolved(const ResolvedPaths(git: '/tmp/clide-no-such-git-binary'));
final t = ToolchainView.resolved(const ResolvedPaths(git: '/tmp/clide-no-such-git-binary'));
final dir = await Directory.systemTemp.createTemp('clide-git-bad-');
addTearDown(() => dir.deleteSync(recursive: true));
final git = GitClient(toolchain: t, workDir: dir);
test/pql/client_test.dart
+3 -5
View File
@@ -5,15 +5,14 @@ library;
import 'dart:io';
import 'package:clide/kernel/src/toolchain.dart';
import 'package:clide/kernel/src/toolchain_paths.dart';
import 'package:clide/src/pql/client.dart';
import 'package:test/test.dart';
void main() {
late PqlClient pql;
setUp(() {
final toolchain = Toolchain();
toolchain.applyResolved(Toolchain.resolvePaths(workspaceRoot: Directory.current.path));
final toolchain = ToolchainView.resolved(resolveToolchainPaths(Directory.current.path));
pql = PqlClient(workDir: Directory.current, toolchain: toolchain);
});
@@ -123,9 +122,8 @@ void main() {
group('PqlClient — error surface', () {
test('non-existent pql binary raises a PqlException with ProcessException details', () async {
final t = Toolchain();
// Inject a bad path — Process.run will throw ProcessException.
t.applyResolved(const ResolvedPaths(pql: '/tmp/clide-no-such-pql-binary'));
final t = ToolchainView.resolved(const ResolvedPaths(pql: '/tmp/clide-no-such-pql-binary'));
final bad = PqlClient(workDir: Directory.current, toolchain: t);
try {
await bad.files();