cobra_commander 1.0.1 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5f6e4d7e8d890c46aed5efff6219f669e79f64325f6f73c899cf6a0c5959088
-  data.tar.gz: 3fe47e6df4f555345c640051ff6aebf25dea8a5907507e6be4ebcc18876897c1
+  metadata.gz: 3e4912ef5e1373f254652d50f2c88bd5d6fc2785675f2d53bdf3572ffcbfafaf
+  data.tar.gz: 5c0bdd82e4ea3fcffeb1f8d7a44aece59ca929d40171f3c22b6a3c95d951b942
 SHA512:
-  metadata.gz: 0add3576fb98e23aa8332939c2c19d7b4dd04cb82ab3d7cebb12191687fbe72e43efad27ddfa24c80d4393d63898f8f01915af1aa6a74a2331c00c1f57dc99a6
-  data.tar.gz: '03942e8553ee6163ad3703ce4be836ec2d538ea908cbd32d7fcd274a01b316a37f77407e32758c8d57043ec3e5a0b30007b7398e1c1a0d21018e245d8c2c09d6'
+  metadata.gz: 3d8882fe6141cc4ddc6c7ec92616aceb7010c3d889b8c6b7f2d039d589fcd1c9bed43d8dcac946f239057f27eb2ab51c5cd65a181a838401cff2e38f6edb1e8d
+  data.tar.gz: ceda5086044a31eae40445597289fae8c23aef320160b07b8d9a1b3fc33ea9318eb2815e97781af5a70f4295842bc59e07e9cc562473fa92933c837db47a9f36

data/cobra_commander.gemspec

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
-lib = File.expand_path("lib", __dir__)
-$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
-require "cobra_commander/version"
+require_relative "lib/cobra_commander/version"
 
 Gem::Specification.new do |spec|
   spec.name = "cobra_commander"
@@ -31,19 +29,15 @@ Gem::Specification.new do |spec|
   spec.metadata["source_code_uri"] = "https://github.com/powerhome/cobra_commander"
   spec.metadata["changelog_uri"] = "https://github.com/powerhome/cobra_commander/blob/main/cobra_commander/docs/CHANGELOG.md"
 
-  spec.files = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(test|spec|features)/})
-  end
+  spec.files = Dir["{docs,exe,lib}/**/*"] + ["cobra_commander.gemspec"]
   spec.bindir = "exe"
-  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
+  spec.executables = %w[cobra]
+  spec.require_paths = %w[lib]
 
   spec.add_dependency "bundler"
-  spec.add_dependency "concurrent-ruby", "~> 1.1"
   spec.add_dependency "thor", ["< 2.0", ">= 0.18.1"]
   spec.add_dependency "tty-command", "~> 0.10.0"
   spec.add_dependency "tty-prompt", "~> 0.23.1"
-  spec.add_dependency "tty-spinner", "~> 0.9.3"
 
   spec.add_development_dependency "aruba", "~> 0.14.2"
   spec.add_development_dependency "bundler"

data/docs/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Change Log
 
+## Unreleased
+
+## Version 1.1.0 - 2023-03-09
+
+* New Executor by @xjunior in [#104](https://github.com/powerhome/cobra_commander/pull/104)
+* Cleanup cobra changes by @xjunior in [#105](https://github.com/powerhome/cobra_commander/pull/105)
+
 ## Version 1.0.1 - 2023-01-05
 
 * Fix Umbrella#resolve unable to resolve a path relative to the project @xjunior [#103](https://github.com/powerhome/cobra_commander/pull/103)

data/lib/cobra_commander/affected.rb

@@ -1,25 +1,19 @@
 # frozen_string_literal: true
 
-require "json"
-
 module CobraCommander
   # Calculates directly & transitively affected components
+  # Takes a list of changes, and resolves all components affected
+  #
   class Affected
+    include Enumerable
+
     def initialize(umbrella, changes)
       @umbrella = umbrella
       @changes = changes
     end
 
-    def names
-      @names ||= all.map(&:name)
-    end
-
-    def all
-      @all ||= (directly | transitively).sort_by(&:name)
-    end
-
-    def scripts
-      @scripts ||= paths.map { |path| path.join("test.sh") }
+    def each(&block)
+      (directly | transitively).sort_by(&:name).each(&block)
     end
 
     def directly
@@ -31,34 +25,5 @@ module CobraCommander
       @transitively ||= directly.flat_map(&:deep_dependents)
                                 .uniq.sort_by(&:name)
     end
-
-    def to_json(*_args)
-      {
-        changed_files: @changes,
-        directly_affected_components: directly.map { |c| affected_component(c) },
-        transitively_affected_components: transitively.map { |c| affected_component(c) },
-        test_scripts: scripts,
-        component_names: names,
-        languages: all_affected_packages,
-      }.to_json
-    end
-
-  private
-
-    def affected_component(component)
-      {
-        name: component.name,
-        path: component.root_paths.map(&:to_s),
-        type: component.packages.map(&:key).map(&:to_s),
-      }
-    end
-
-    def paths
-      @paths ||= all.map(&:root_paths).flatten
-    end
-
-    def all_affected_packages
-      all.flat_map(&:packages).map(&:key).uniq
-    end
   end
 end

data/lib/cobra_commander/cli/filters.rb

@@ -29,7 +29,7 @@ module CobraCommander
 
     def affected_by_changes(origin_branch)
       changes = GitChanged.new(umbrella.path, origin_branch)
-      Affected.new(umbrella, changes).all
+      Affected.new(umbrella, changes).to_a
     end
 
     def filter_component(component_name)

data/lib/cobra_commander/cli/output/change.rb

@@ -6,27 +6,19 @@ require "cobra_commander/affected"
 module CobraCommander
   class CLI
     module Output
-      # Calculates and prints affected components & files
       class Change
-        InvalidSelectionError = Class.new(StandardError)
-
-        def initialize(umbrella, oformat, branch, changes: nil)
-          @format = oformat
+        def initialize(umbrella, branch, changes: nil)
           @branch = branch
           @umbrella = umbrella
           @changes = changes || GitChanged.new(umbrella.path, branch)
         end
 
         def run!
-          assert_valid_result_choice
-          if selected_format?("json")
-            puts affected.to_json
-          else
-            show_full if selected_format?("full")
-            tests_to_run
-          end
-        rescue GitChanged::InvalidSelectionError => e
-          puts e.message
+          print_changes_since_last_commit
+          puts
+          print_directly_affected_components
+          puts
+          print_transitively_affected_components
         end
 
       private
@@ -35,55 +27,23 @@ module CobraCommander
           @affected ||= Affected.new(@umbrella, @changes)
         end
 
-        def show_full
-          changes_since_last_commit
-          directly_affected_components
-          transitively_affected_components
-        end
-
-        def assert_valid_result_choice
-          return if %w[test full name json].include?(@format)
-
-          raise InvalidSelectionError, "--results must be 'test', 'full', 'name' or 'json'"
-        end
-
-        def selected_format?(result)
-          @format == result
-        end
-
-        def changes_since_last_commit
+        def print_changes_since_last_commit
           puts "<<< Changes since last commit on #{@branch} >>>"
           puts(*@changes) if @changes.any?
-          puts blank_line
         end
 
-        def directly_affected_components
+        def print_directly_affected_components
           puts "<<< Directly affected components >>>"
-          affected.directly.each { |component| puts display(component) }
-          puts blank_line
+          affected.directly.each { |component| display(component) }
         end
 
-        def transitively_affected_components
+        def print_transitively_affected_components
           puts "<<< Transitively affected components >>>"
-          affected.transitively.each { |component| puts display(component) }
-          puts blank_line
-        end
-
-        def tests_to_run
-          puts "<<< Test scripts to run >>>" if selected_format?("full")
-          if selected_format?("name")
-            affected.names.each { |component_name| puts component_name }
-          else
-            affected.scripts.each { |component_script| puts component_script }
-          end
+          affected.transitively.each { |component| display(component) }
         end
 
         def display(component)
-          "#{component.name} - #{component.packages.map(&:key).map(&:to_s).map(&:capitalize).join(' & ')}"
-        end
-
-        def blank_line
-          ""
+          puts "#{component.name} - #{component.packages.map(&:key).map(&:to_s).map(&:capitalize).join(' & ')}"
         end
       end
     end

data/lib/cobra_commander/cli.rb

@@ -1,21 +1,20 @@
 # frozen_string_literal: true
 
+require "etc"
 require "thor"
 require "fileutils"
-require "concurrent-ruby"
-
 require "cobra_commander"
 
 module CobraCommander
   # Implements the tool's CLI
   class CLI < Thor
+    DEFAULT_CONCURRENCY = (Etc.nprocessors / 2.0).ceil
+
     require_relative "cli/filters"
     require_relative "cli/output/ascii_tree"
     require_relative "cli/output/change"
     require_relative "cli/output/dot_graph"
 
-    DEFAULT_CONCURRENCY = (Concurrent.processor_count / 2.0).ceil
-
     class_option :app, default: Dir.pwd, aliases: "-a", type: :string
     Source.all.keys.each do |key|
       class_option key, default: false, type: :boolean, desc: "Consider only the #{key} dependency graph"
@@ -39,40 +38,36 @@ module CobraCommander
                                        "Defaults to all components."
     filter_options dependents: "Run the script on each dependent of a given component",
                    dependencies: "Run the script on each dependency of a given component"
-    method_option :concurrency, type: :numeric, default: DEFAULT_CONCURRENCY, aliases: "-c",
-                                desc: "Max number of jobs to run concurrently"
+    method_option :concurrency, type: :numeric, aliases: "-c", desc: "Max number of jobs to run concurrently",
+                                default: DEFAULT_CONCURRENCY
     method_option :interactive, type: :boolean, default: true, aliases: "-i",
                                 desc: "Runs in interactive mode to allow the user to inspect the output of each " \
                                       "component"
     def exec(script_or_components, script = nil)
-      jobs = CobraCommander::Executor::Script.for(
-        components_filtered(script && script_or_components),
-        script || script_or_components
+      CobraCommander::Executor.execute_and_handle_exit(
+        runner: ::CobraCommander::Executor::Script.new(script || script_or_components),
+        workers: options.concurrency,
+        interactive: options.interactive,
+        jobs: components_filtered(script && script_or_components)
       )
-      output_mode = options.interactive && jobs.count > 1 ? :interactive : :markdown
-      execution = CobraCommander::Executor.execute(jobs: jobs, workers: options.concurrency,
-                                                   output_mode: output_mode, output: $stdout, status_output: $stderr)
-      exit 1 unless execution.success?
     end
 
     desc "cmd [components] <command>", "Executes the command in the context of a given component or set thereof. " \
                                        "Defaults to all components."
     filter_options dependents: "Run the command on each dependent of a given component",
                    dependencies: "Run the command on each dependency of a given component"
-    method_option :concurrency, type: :numeric, default: DEFAULT_CONCURRENCY, aliases: "-c",
-                                desc: "Max number of jobs to run concurrently"
+    method_option :concurrency, type: :numeric, aliases: "-c", desc: "Max number of jobs to run concurrently",
+                                default: DEFAULT_CONCURRENCY
     method_option :interactive, type: :boolean, default: true, aliases: "-i",
                                 desc: "Runs in interactive mode to allow the user to inspect the output of each " \
                                       "component"
     def cmd(command_or_components, command = nil)
-      jobs = CobraCommander::Executor::Command.for(
-        components_filtered(command && command_or_components),
-        command || command_or_components
+      CobraCommander::Executor.execute_and_handle_exit(
+        runner: ::CobraCommander::Executor::Command.new(command || command_or_components),
+        workers: options.concurrency,
+        interactive: options.interactive,
+        jobs: components_filtered(command && command_or_components).flat_map(&:packages)
       )
-      output_mode = options.interactive && jobs.count > 1 ? :interactive : :markdown
-      execution = CobraCommander::Executor.execute(jobs: jobs, workers: options.concurrency,
-                                                   output_mode: output_mode, output: $stdout, status_output: $stderr)
-      exit 1 unless execution.success?
     end
 
     desc "tree [component]", "Prints the dependency tree of a given component or umbrella"
@@ -97,22 +92,18 @@ module CobraCommander
     end
 
     desc "changes [--results=RESULTS] [--branch=BRANCH]", "Prints list of changed files"
-    method_option :results, default: "test", aliases: "-r", desc: "Accepts test, full, name or json"
     method_option :branch, default: "master", aliases: "-b", desc: "Specified target to calculate against"
     def changes
-      Output::Change.new(umbrella, options.results, options.branch).run!
+      Output::Change.new(umbrella, options.branch).run!
     end
 
   private
 
     def umbrella
-      selector = Source.all.keys.reduce({}) do |sel, key|
+      selector = CobraCommander::Source.all.keys.reduce({}) do |sel, key|
         sel.merge(key => options.public_send(key))
       end
-      @umbrella ||= CobraCommander::Umbrella.new(
-        options.app,
-        **selector
-      )
+      @umbrella ||= CobraCommander::Umbrella.new(options.app, **selector)
     rescue ::CobraCommander::Source::Error => e
       error(e.message)
       exit(1)

data/lib/cobra_commander/component.rb

@@ -12,6 +12,10 @@ module CobraCommander
       @packages = []
     end
 
+    def describe
+      "#{name} (#{packages.map(&:key).join(', ')})"
+    end
+
     def add_package(package)
       @packages << package
       @dependency_names |= package.dependencies

data/lib/cobra_commander/executor/buffered_printer.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module CobraCommander
+  module Executor
+    class BufferedPrinter < TTY::Command::Printers::Null
+      TIME_FORMAT = "Finished in %5.3fs"
+
+      def initialize(*)
+        super
+
+        @buffers = Hash.new { |h, k| h[k] = StringIO.new }
+      end
+
+      def write(cmd, message)
+        @buffers[cmd.uuid].write message
+      end
+
+      def print_command_out_data(cmd, *args)
+        write(cmd, args.join)
+      end
+
+      def print_command_err_data(cmd, *args)
+        write(cmd, args.join)
+      end
+
+      def print_command_start(cmd, *args)
+        message = "Running #{decorate(cmd.to_command, :yellow, :bold)} #{args.join(' ')}"
+        write(cmd, message)
+      end
+
+      def print_command_exit(cmd, status, runtime, *)
+        message = TIME_FORMAT % runtime
+        message << " with exit status #{status}" if status
+
+        output.puts @buffers.delete(cmd.uuid).string
+        output.puts decorate(message, status == 0 ? :green : :red)
+        output.puts
+      end
+    end
+  end
+end

data/lib/cobra_commander/executor/command.rb

@@ -1,74 +1,49 @@
 # frozen_string_literal: true
 
-require_relative "./job"
-require_relative "./package_criteria"
-
 module CobraCommander
   module Executor
     class Command
-      include ::CobraCommander::Executor::Job
       include ::CobraCommander::Executor::PackageCriteria
+      include ::CobraCommander::Executor::RunScript
 
       SKIP_UNEXISTING = "Command %s does not exist. Check your cobra.yml for existing commands in %s."
       SKIP_CRITERIA = "Package %s does not match criteria."
 
-      # Builds the given commands in all packages of all components.
-      #
-      # @param components [Enumerable<CobraCommander::Component>] the target components
-      # @param command [String] shell script to run from the directories of the component's packages
-      # @return [Array<CobraCommander::Executor::Command>]
-      def self.for(components, command)
-        components.flat_map(&:packages).map do |package|
-          new(package, command)
-        end
+      def initialize(command_name)
+        @command_name = command_name
       end
 
       # Calls the commands sequentially, stopping ony if an :error happens.
       #
       # If one of the commands skips, the result will be :success.
       #
-      # @param commands [Enumerable<CobraCommander::Component>] the target components
-      # @return [Array<CobraCommander::Executor::Command>]
-      # @see CobraCommander::Executor::Job
-      def self.join(commands)
-        commands.lazy.map(&:call).reduce do |(_, prev_output), (result, output)|
-          new_output = [prev_output&.strip, output&.strip].join("\n")
-          return [:error, new_output] if result == :error
-
-          [:success, new_output]
-        end
+      # @param tty [CobraComander::Executor::IsolatedPTY] tty to execute shell scripts
+      # @param package [CobraComander::Package] target package to execute the named command
+      # @return [Array<Symbol, String>]
+      def call(tty, package)
+        run_command tty, package, @command_name
       end
 
-      def initialize(package, command)
-        @package = package
-        @command = command
-      end
-
-      def to_s
-        "#{@package.name} (#{@package.key})"
-      end
+    private
 
-      # @see CobraCommander::Executor::Job
-      def call
-        command = @package.source.config&.dig("commands", @command)
-        case command
-        when Array then run_multiple(@package, command)
-        when Hash then run_with_criteria(command)
-        when nil then skip(format(SKIP_UNEXISTING, @command, @package.key))
-        else run_script(command, @package.path)
+      def run_command(tty, package, command_name)
+        definition = package.source.config&.dig("commands", command_name)
+        case definition
+        when Array then run_multiple(tty, package, definition)
+        when Hash then run_with_criteria(tty, package, definition)
+        when nil then [:skip, format(SKIP_UNEXISTING, command_name, package.key)]
+        else run_script(tty, definition, package.path)
         end
       end
 
-    private
-
-      def run_with_criteria(command)
-        return skip(format(SKIP_CRITERIA, @package.name)) unless match_criteria?(@package, command.fetch("if", {}))
+      def run_with_criteria(tty, package, command)
+        return [:skip, format(SKIP_CRITERIA, package.name)] unless match_criteria?(package, command.fetch("if", {}))
 
-        run_script(command["run"], @package.path)
+        run_script(tty, command["run"], package.path)
       end
 
-      def run_multiple(package, commands)
-        Command.join(commands.map { |command| Command.new(package, command) })
+      def run_multiple(tty, package, commands)
+        run_many(commands) { run_command(tty, package, _1) }
       end
     end
   end

data/lib/cobra_commander/executor/isolated_pty.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module CobraCommander
+  module Executor
+    #
+    # Executes commands in a clean environment, without the influence
+    # of the current Bundler env vars.
+    #
+    class IsolatedPTY < ::TTY::Command
+      def initialize(**kwargs)
+        super(pty: true, **kwargs)
+      end
+
+      def run!(...)
+        isolate_bundle do
+          super(...)
+        end
+      end
+
+      def isolate_bundle(&block)
+        if Bundler.respond_to?(:with_unbundled_env)
+          Bundler.with_unbundled_env(&block)
+        else
+          Bundler.with_clean_env(&block)
+        end
+      end
+    end
+  end
+end

data/lib/cobra_commander/executor/output_prompt.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module CobraCommander
+  module Executor
+    # Runs an interactive output printer
+    class OutputPrompt
+      def self.run(pool, output = $stdout)
+        new(pool.jobs).run(output)
+      end
+
+      pastel = Pastel.new
+      ICONS = {
+        nil => pastel.dim("⦻"),
+        success: pastel.green("✔"),
+        skip: pastel.yellow("↷"),
+        error: pastel.red("✖"),
+      }.freeze
+      CANCELLED = pastel.dim("(cancelled)")
+      BYE = pastel.bold("\n\n👋 Bye!")
+
+      def initialize(jobs)
+        @jobs = jobs
+        @prompt = TTY::Prompt.new(symbols: { cross: " " })
+      end
+
+      def options
+        @options ||= @jobs.map do |job|
+          {
+            name: format_name(job),
+            value: job,
+            disabled: !job.resolved? && CANCELLED,
+          }
+        end
+      end
+
+      def run(output)
+        return unless @jobs.any?(&:resolved?)
+
+        selected = nil
+        output.puts
+        loop do
+          selected = @prompt.select("Print output?", options, default: format_name(selected))
+          output.puts nil, selected.output, nil
+        rescue TTY::Reader::InputInterrupt
+          output.puts BYE
+          break
+        end
+      end
+
+    private
+
+      def format_name(job)
+        return unless job
+
+        "#{ICONS[job.status]} #{job.name}"
+      end
+    end
+  end
+end

data/lib/cobra_commander/executor/package_criteria.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "./job"
-require_relative "./package_criteria"
-
 module CobraCommander
   module Executor
     module PackageCriteria

data/lib/cobra_commander/executor/run_script.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module CobraCommander
+  module Executor
+    module RunScript
+      def run_script(tty, script, path)
+        result = tty.run!(script, chdir: path, err: :out)
+
+        return [:error, result.out] if result.failed?
+
+        [:success, result.out]
+      end
+
+      def run_many(collection, &block)
+        collection.lazy.map(&block)
+                  .reduce do |(_, prev_output), (result, output)|
+          new_output = [prev_output&.strip, output&.strip].join("\n")
+          return [:error, new_output] if result == :error
+
+          [:success, new_output]
+        end
+      end
+    end
+  end
+end

data/lib/cobra_commander/executor/script.rb

@@ -1,44 +1,28 @@
 # frozen_string_literal: true
 
-require_relative "./job"
-
 module CobraCommander
   module Executor
-    # This is a script job. It can tarket any CobraCommander::Package.
+    # This is a script job. It can target any CobraCommander::Component.
     #
-    # If you want to target a Component, you can use Script.for to target
-    # individual paths for each given component.
+    # Script runs the given script once for each Component#root_paths
     #
-    # @see Script.for
     class Script
-      include ::CobraCommander::Executor::Job
-
-      # Returns a set of scripts to be executed on the given commends.
-      #
-      # If a component has two packages in the same path, only one script for that component will be
-      # returned.
-      #
-      # @param components [Enumerable<CobraCommander::Component>] the target components
-      # @param script [String] shell script to run from the directories of the component's packages
-      # @return [Array<CobraCommander::Executor::Script>]
-      def self.for(components, script)
-        components.flat_map(&:packages).uniq(&:path).map do |package|
-          new(package, script)
-        end
-      end
+      include ::CobraCommander::Executor::RunScript
 
-      def initialize(package, script)
-        @package = package
+      def initialize(script)
         @script = script
       end
 
-      def to_s
-        @package.name
-      end
-
-      # @see CobraCommander::Executor::Job
-      def call
-        run_script @script, @package.path
+      # Runs the script in the given component
+      #
+      # It runs the script once for each Component#root_paths. If a component has two packages in the
+      # same path, it will run the script only once.
+      #
+      # @param tty [CobraComander::Executor::IsolatedPTY] tty to execute shell scripts
+      # @param component [CobraComander::Component] target component
+      # @return [Array<Symbol, String>]
+      def call(tty, component)
+        run_many(component.root_paths) { run_script(tty, @script, _1) }
       end
     end
   end