chore(split): splitting in multiple commands (#4)

.github/cspell.json

@@ -19,6 +19,7 @@
   ],
   "useGitignore": true,
   "words": [
-    "worktree"
+    "worktree",
+    "goldens"
   ]
 }

README.md

@@ -30,19 +30,20 @@ dart pub global activate --source=path <path to this package>
 # Execute golden test using main branch as reference
 $ golden test
 
-# Execute golden test using a specific branch as reference
-$ golden test feature/branch
-
-# Available options
-## --no-generate: Skip golden file generation
-## --no-execute: Skip golden file comparison
-## --no-cleanup: Skip git worktree cleanup
-## feature/branch: Branch name to compare against
-$ golden test \
-    --no-generate \
-    --no-execute \
-    --no-cleanup \
-    feature/branch
+# cleanup
+$ golden clean
+
+# generate golden files
+$ golden gen
+
+# get goldens without generating them
+$ golden get
+
+# Using a specific branch
+$ golden test -r feature/branch
+$ golden clean -r feature/branch
+$ golden gen -r feature/branch
+$ golden get -r feature/branch
 
 # Show CLI version
 $ golden --version

lib/src/command_runner.dart

@@ -4,6 +4,7 @@ import 'package:cli_completion/cli_completion.dart';
 import 'package:file/file.dart';
 import 'package:file/local.dart';
 import 'package:golden_cli/src/commands/commands.dart';
+import 'package:golden_cli/src/services/golden_service.dart';
 import 'package:golden_cli/src/version.dart';
 import 'package:mason_logger/mason_logger.dart';
 import 'package:process/process.dart';
@@ -28,8 +29,15 @@ class GoldenCliCommandRunner extends CompletionCommandRunner<int> {
     PubUpdater? pubUpdater,
     ProcessManager processManager = const LocalProcessManager(),
     FileSystem fileSystem = const LocalFileSystem(),
+    GoldenService? goldenService,
   })  : _logger = logger ?? Logger(),
         _pubUpdater = pubUpdater ?? PubUpdater(),
+        _goldenService = goldenService ??
+            GoldenService(
+              logger: logger ?? Logger(),
+              processManager: processManager,
+              fileSystem: fileSystem,
+            ),
         super(executableName, description) {
     // Add root options and flags
     argParser
@@ -45,12 +53,29 @@ class GoldenCliCommandRunner extends CompletionCommandRunner<int> {
       );
 
     // Add sub commands
+    addCommand(
+      CleanCommand(
+        logger: _logger,
+        goldenService: _goldenService,
+      ),
+    );
+    addCommand(
+      GenCommand(
+        logger: _logger,
+        goldenService: _goldenService,
+      ),
+    );
+    addCommand(
+      GetCommand(
+        logger: _logger,
+        goldenService: _goldenService,
+      ),
+    );
     addCommand(SampleCommand(logger: _logger));
     addCommand(
       TestCommand(
         logger: _logger,
-        processManager: processManager,
-        fileSystem: fileSystem,
+        goldenService: _goldenService,
       ),
     );
     addCommand(UpdateCommand(logger: _logger, pubUpdater: _pubUpdater));
@@ -61,6 +86,7 @@ class GoldenCliCommandRunner extends CompletionCommandRunner<int> {
 
   final Logger _logger;
   final PubUpdater _pubUpdater;
+  final GoldenService _goldenService;
 
   @override
   Future<int> run(Iterable<String> args) async {

lib/src/commands/clean_command.dart

@@ -0,0 +1,46 @@
+import 'package:args/command_runner.dart';
+import 'package:golden_cli/src/services/golden_service.dart';
+import 'package:mason_logger/mason_logger.dart';
+
+/// {@template clean_command}
+///
+/// `golden clean`
+/// A [Command] to clean the git worktree and remove the branch.
+/// {@endtemplate}
+class CleanCommand extends Command<int> {
+  /// {@macro clean_command}
+  CleanCommand({
+    required Logger logger,
+    required GoldenService goldenService,
+  })  : _logger = logger,
+        _goldenService = goldenService {
+    argParser.addOption(
+      'ref',
+      abbr: 'r',
+      help: 'Git refence to compare against',
+      defaultsTo: 'main',
+    );
+  }
+
+  @override
+  String get description => 'Clean the git worktree and remove the branch';
+
+  @override
+  String get name => 'clean';
+
+  final Logger _logger;
+
+  final GoldenService _goldenService;
+
+  @override
+  Future<int> run() async {
+    final ref = argResults!['ref'] as String;
+
+    _logger.info('Cleaning up worktree and branch $ref');
+
+    await _goldenService.doCleanup(ref);
+
+    _logger.info('Done!');
+    return ExitCode.success.code;
+  }
+}

lib/src/commands/commands.dart

@@ -1,3 +1,6 @@
+export 'clean_command.dart';
+export 'gen_command.dart';
+export 'get_command.dart';
 export 'sample_command.dart';
 export 'test_command.dart';
 export 'update_command.dart';

lib/src/commands/gen_command.dart

@@ -0,0 +1,80 @@
+import 'package:args/command_runner.dart';
+import 'package:golden_cli/src/services/golden_service.dart';
+import 'package:mason_logger/mason_logger.dart';
+
+/// {@template gen_command}
+///
+/// `golden gen`
+/// A [Command] to generate the golden files from a git reference and copy them
+/// {@endtemplate}
+class GenCommand extends Command<int> {
+  /// {@macro gen_command}
+  GenCommand({
+    required Logger logger,
+    required GoldenService goldenService,
+  })  : _logger = logger,
+        _goldenService = goldenService {
+    argParser.addOption(
+      'ref',
+      abbr: 'r',
+      help: 'Git refence to compare against',
+      defaultsTo: 'main',
+    );
+  }
+
+  @override
+  String get description => 'Generate the golden files from a git reference';
+
+  @override
+  String get name => 'gen';
+
+  final Logger _logger;
+
+  final GoldenService _goldenService;
+
+  @override
+  Future<int> run() async {
+    final ref = argResults!['ref'] as String;
+
+    _logger.info('Getting golden files from $ref');
+
+    final checkRefProgress = await _goldenService.checkRef(ref: ref);
+    if (checkRefProgress.exitCode != 0 ||
+        checkRefProgress.stdout.toString().isEmpty) {
+      _logger
+        ..err('Failed to check ref $ref')
+        ..err(checkRefProgress.stderr.toString());
+      return ExitCode.software.code;
+    }
+    _logger.info(checkRefProgress.stdout.toString());
+
+    await _goldenService.doCleanup(ref);
+
+    _logger.info('Adding $ref to the worktree');
+    final addWorktreeProgress = await _goldenService.addWorktree(ref: ref);
+    if (addWorktreeProgress.exitCode != 0) {
+      _logger
+        ..err('Failed to add worktree for ref $ref')
+        ..err(addWorktreeProgress.stderr.toString());
+      return ExitCode.software.code;
+    }
+    _logger.info(addWorktreeProgress.stdout.toString());
+
+    // ignore: cascade_invocations
+    _logger.info('Generating golden files using $ref');
+    final generateGoldensProgress =
+        await _goldenService.generateGoldens(ref: ref);
+    if (generateGoldensProgress.exitCode != 0) {
+      _logger
+        ..err('Failed to generate golden files for ref $ref')
+        ..err(generateGoldensProgress.stderr.toString());
+      return ExitCode.software.code;
+    }
+    _logger.info(generateGoldensProgress.stdout.toString());
+
+    await _goldenService.fetchGoldens();
+
+    _logger.info('Done!');
+    return ExitCode.success.code;
+  }
+}

lib/src/commands/get_command.dart

@@ -0,0 +1,68 @@
+import 'package:args/command_runner.dart';
+import 'package:golden_cli/src/services/golden_service.dart';
+import 'package:mason_logger/mason_logger.dart';
+
+/// {@template get_command}
+///
+/// `golden get`
+/// A [Command] to get the golden files from a git reference.
+/// {@endtemplate}
+class GetCommand extends Command<int> {
+  /// {@macro get_command}
+  GetCommand({
+    required Logger logger,
+    required GoldenService goldenService,
+  })  : _logger = logger,
+        _goldenService = goldenService {
+    argParser.addOption(
+      'ref',
+      abbr: 'r',
+      help: 'Git refence to compare against',
+      defaultsTo: 'main',
+    );
+  }
+
+  @override
+  String get description => 'Get the golden files from a git reference';
+
+  @override
+  String get name => 'get';
+
+  final Logger _logger;
+
+  final GoldenService _goldenService;
+
+  @override
+  Future<int> run() async {
+    final ref = argResults!['ref'] as String;
+
+    _logger.info('Getting golden files from $ref');
+
+    final checkRefProgress = await _goldenService.checkRef(ref: ref);
+    if (checkRefProgress.exitCode != 0 ||
+        checkRefProgress.stdout.toString().isEmpty) {
+      _logger
+        ..err('Failed to check ref $ref')
+        ..err(checkRefProgress.stderr.toString());
+      return ExitCode.software.code;
+    }
+    _logger.info(checkRefProgress.stdout.toString());
+
+    await _goldenService.doCleanup(ref);
+
+    _logger.info('Adding $ref to the worktree');
+    final addWorktreeProgress = await _goldenService.addWorktree(ref: ref);
+    if (addWorktreeProgress.exitCode != 0) {
+      _logger
+        ..err('Failed to add worktree for ref $ref')
+        ..err(addWorktreeProgress.stderr.toString());
+      return ExitCode.software.code;
+    }
+    _logger.info(addWorktreeProgress.stdout.toString());
+
+    await _goldenService.fetchGoldens();
+
+    _logger.info('Done!');
+    return ExitCode.success.code;
+  }
+}