cobra_commander 0.15.0 → 1.0.0

data/lib/cobra_commander/cli.rb

@@ -5,22 +5,21 @@ require "fileutils"
 require "concurrent-ruby"
 
 require "cobra_commander"
-require "cobra_commander/affected"
-require "cobra_commander/change"
-require "cobra_commander/git_changed"
-require "cobra_commander/executor"
-require "cobra_commander/output"
 
 module CobraCommander
   # Implements the tool's CLI
   class CLI < Thor
-    require "cobra_commander/cli/filters"
+    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
-    class_option :js, default: false, type: :boolean, desc: "Consider only the JS dependency graph"
-    class_option :ruby, default: false, type: :boolean, desc: "Consider only the Ruby dependency graph"
+    Source.all.keys.each do |key|
+      class_option key, default: false, type: :boolean, desc: "Consider only the #{key} dependency graph"
+    end
 
     desc "version", "Prints version"
     def version
@@ -33,11 +32,31 @@ module CobraCommander
     method_option :total, type: :boolean, aliases: "-t", desc: "Prints the total count of components"
     def ls(components = nil)
       components = components_filtered(components)
-      puts options.total ? components.size : CobraCommander::Output::FlatList.new(components).to_s
+      puts options.total ? components.size : components.map(&:name).sort
+    end
+
+    desc "exec [components] <script>", "Executes the script in the context of a given component or set thereof. " \
+                                       "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 :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
+      )
+      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 "exec [components] <command>", "Executes the command in the context of a given component or set thereof. " \
-                                        "Defaults to all components."
+    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",
@@ -45,49 +64,58 @@ module CobraCommander
     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(command_or_components, command = nil)
-      results = CobraCommander::Executor.exec(
-        components: components_filtered(command && command_or_components),
-        command: command || command_or_components,
-        concurrency: options.concurrency, status_output: $stderr
+    def cmd(command_or_components, command = nil)
+      jobs = CobraCommander::Executor::Command.for(
+        components_filtered(command && command_or_components),
+        command || command_or_components
       )
-      if options.interactive && results.size > 1
-        CobraCommander::Output::InteractivePrinter.run(results, $stdout)
-      else
-        CobraCommander::Output::MarkdownPrinter.run(results, $stdout)
-      end
+      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"
     def tree(component = nil)
-      component = find_component(component)
-      puts CobraCommander::Output::AsciiTree.new(component).to_s
+      components = component ? [find_component(component)] : umbrella.components
+      puts Output::AsciiTree.new(components).to_s
     end
 
     desc "graph [component]", "Outputs a graph of a given component or umbrella"
-    method_option :output, default: File.join(Dir.pwd, "output.png"), aliases: "-o",
-                           desc: "Output file, accepts .png or .dot"
+    method_option :output, default: File.join(Dir.pwd, "output.dot"), aliases: "-o"
     def graph(component = nil)
-      CobraCommander::Output::GraphViz.generate(
-        find_component(component),
-        options.output
+      output = File.open(options.output, "w")
+      Output::DotGraph.generate(
+        component ? [find_component(component)] : umbrella.components,
+        output
       )
       puts "Graph generated at #{options.output}"
     rescue ArgumentError => e
       error e.message
+    ensure
+      output&.close
     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
-      Change.new(umbrella, options.results, options.branch).run!
+      Output::Change.new(umbrella, options.results, options.branch).run!
     end
 
   private
 
     def umbrella
-      @umbrella ||= CobraCommander.umbrella(options.app, yarn: options.js, bundler: options.ruby)
+      selector = Source.all.keys.reduce({}) do |sel, key|
+        sel.merge(key => options.public_send(key))
+      end
+      @umbrella ||= CobraCommander::Umbrella.new(
+        options.app,
+        **selector
+      )
+    rescue ::CobraCommander::Source::Error => e
+      error(e.message)
+      exit(1)
     end
   end
 end

data/lib/cobra_commander/component.rb

@@ -9,22 +9,20 @@ module CobraCommander
       @umbrella = umbrella
       @name = name
       @dependency_names = []
-      @packages = {}
+      @packages = []
     end
 
-    def add_package(key, package)
-      @packages[key] = package
+    def add_package(package)
+      @packages << package
       @dependency_names |= package.dependencies
     end
 
     def root_paths
-      @packages.values.map do |package|
-        File.dirname(package.path)
-      end.uniq
+      @packages.map(&:path).uniq
     end
 
     def inspect
-      "#<CobraCommander::Component:#{object_id} #{name} dependencies=#{dependencies.map(&:name)} packages=#{sources}>"
+      "#<CobraCommander::Component:#{object_id} #{name} dependencies=#{dependencies.map(&:name)} packages=#{packages}>"
     end
 
     def deep_dependents
@@ -46,9 +44,7 @@ module CobraCommander
     end
 
     def dependencies
-      @dependencies ||= @dependency_names.sort
-                                         .map(&@umbrella.method(:find))
-                                         .compact
+      @dependencies ||= @dependency_names.sort.filter_map { |name| @umbrella.find(name) }
     end
   end
 end

data/lib/cobra_commander/executor/command.rb

@@ -0,0 +1,75 @@
+# 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
+
+      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
+      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
+      end
+
+      def initialize(package, command)
+        @package = package
+        @command = command
+      end
+
+      def to_s
+        "#{@package.name} (#{@package.key})"
+      end
+
+      # @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)
+        end
+      end
+
+    private
+
+      def run_with_criteria(command)
+        return skip(format(SKIP_CRITERIA, @package.name)) unless match_criteria?(@package, command.fetch("if", {}))
+
+        run_script(command["run"], @package.path)
+      end
+
+      def run_multiple(package, commands)
+        Command.join(commands.map { |command| Command.new(package, command) })
+      end
+    end
+  end
+end

data/lib/cobra_commander/executor/execution.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require "concurrent-ruby"
+
+module CobraCommander
+  module Executor
+    # A threaded execution environment, limited by the number of given workers
+    class Execution < Hash
+      #
+      # @param jobs [Array<#call>] array of job objects
+      # @param workers [Integer] number of workers to process this execution
+      # @see CobraCommander::Executor::Job
+      def initialize(jobs, workers:)
+        super()
+
+        @executor = Concurrent::FixedThreadPool.new(workers, auto_terminate: true)
+        merge! create_futures(jobs)
+      end
+
+      # Wait for all jobs to complete, returns a future with all execution futures
+      # @return [Concurrent::Promises::Future]
+      def wait
+        Concurrent::Promises.zip_futures_on(@executor, *values)
+                            .tap(&:wait)
+      end
+
+      # The execution succeeds when all jobs succeeded
+      # @return [Boolean]
+      def success?
+        values.all?(&:fulfilled?)
+      end
+
+    private
+
+      def create_future(job)
+        Concurrent::Promises.future_on(@executor, job, &:call).then do |result|
+          status, output = result
+          case status
+          when :error then Concurrent::Promises.rejected_future(output)
+          when :success, :skip then Concurrent::Promises.fulfilled_future(output)
+          else
+            Concurrent::Promises.fulfilled_future(result)
+          end
+        end.flat
+      end
+
+      def create_futures(jobs)
+        jobs.to_h { |job| [job, create_future(job)] }
+      end
+    end
+  end
+end

data/lib/cobra_commander/executor/interactive_printer.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require "pastel"
+require "tty-prompt"
+
+module CobraCommander
+  module Executor
+    # Runs an interactive output printer
+    class InteractivePrinter
+      pastel = Pastel.new
+      SUCCESS = "#{pastel.green('✔')} %s"
+      ERROR = "#{pastel.red('✖')} %s"
+      BYE = pastel.decorate("\n\n👋 Bye!", :white, :on_black, :bold).freeze
+
+      def self.run(execution, output)
+        new(execution).run(output)
+      end
+
+      def initialize(execution)
+        @prompt = TTY::Prompt.new
+        @execution = execution
+      end
+
+      def run(output)
+        selected = nil
+        loop do
+          selected = @prompt.select("Print output?", options, default: options.key(selected))
+          output.puts selected.fulfilled? ? selected.value : selected.reason
+        end
+      rescue TTY::Reader::InputInterrupt
+        output.puts BYE
+      end
+
+    private
+
+      def options
+        @options ||= @execution.sort { |*args| sort_results(*args.flatten) }
+                               .reduce({}) do |options, (job, result)|
+          template = result.rejected? ? ERROR : SUCCESS
+          options.merge format(template, job.to_s) => result
+        end
+      end
+
+      def sort_results(job_a, result_a, job_b, result_b)
+        if result_a.rejected? == result_b.rejected?
+          job_a.to_s <=> job_b.to_s
+        else
+          result_b.rejected? ? 1 : -1
+        end
+      end
+    end
+  end
+end

data/lib/cobra_commander/executor/job.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "tty-command"
+
+module CobraCommander
+  module Executor
+    #
+    # This is a helper module to help jobs return valid errors and success outputs.
+    #
+    # A CobraCommander::Executor::Job is actually any object responding to #call, and returning
+    # valid error or success responses.
+    #
+    # An error is an array containint `:error` and the output (i.e.: [:error, "string output"]).
+    # A success is either an array containint `:success` and the output, or just the output
+    # (i.e.: [:error, "string output"] or just "string output").
+    #
+    module Job
+      def skip(reason)
+        [:skip, reason]
+      end
+
+      def error(output)
+        [:error, output]
+      end
+
+      def success(output)
+        [:success, output]
+      end
+
+      def run_script(script, path)
+        result = isolate_bundle do
+          TTY::Command.new(pty: true, printer: :null)
+                      .run!(script, chdir: path, err: :out)
+        end
+        return error(result.out) if result.failed?
+
+        success(result.out)
+      end
+
+    private
+
+      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/markdown_printer.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module CobraCommander
+  module Executor
+    # Prints the given CobraCommander::Executor::Context to [output] collection in markdown
+    module MarkdownPrinter
+      SUCCESS = "\n## ✔ %s\n"
+      ERROR = "\n## ✖ %s\n"
+      OUTPUT = "\n```\n\n%s\n```\n"
+
+      def self.run(execution, output)
+        execution.each do |job, result|
+          template = result.fulfilled? ? SUCCESS : ERROR
+
+          output.print format(template, job)
+          output.print format(OUTPUT, result.fulfilled? ? result.value : result.reason)
+        end
+      end
+    end
+  end
+end

data/lib/cobra_commander/executor/package_criteria.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative "./job"
+require_relative "./package_criteria"
+
+module CobraCommander
+  module Executor
+    module PackageCriteria
+      def match_criteria?(package, criteria)
+        criteria.all? do |criteria_key, criteria_value|
+          criteria_method = "_match_#{criteria_key}?"
+          !respond_to?(criteria_method, true) || send(criteria_method, package, criteria_value)
+        end
+      end
+
+      def _match_depends_on?(package, packages)
+        (Array(packages) - package.dependencies).empty?
+      end
+    end
+  end
+end

data/lib/cobra_commander/executor/script.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "./job"
+
+module CobraCommander
+  module Executor
+    # This is a script job. It can tarket any CobraCommander::Package.
+    #
+    # If you want to target a Component, you can use Script.for to target
+    # individual paths for each given component.
+    #
+    # @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
+
+      def initialize(package, script)
+        @package = package
+        @script = script
+      end
+
+      def to_s
+        @package.name
+      end
+
+      # @see CobraCommander::Executor::Job
+      def call
+        run_script @script, @package.path
+      end
+    end
+  end
+end

data/lib/cobra_commander/executor/spinners.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "pastel"
+require "tty-spinner"
+
+module CobraCommander
+  module Executor
+    class Spinners
+      pastel = ::Pastel.new
+      SPINNER_OPTIONS = {
+        format: :bouncing,
+        success_mark: pastel.green("[DONE]"),
+        error_mark: pastel.red("[ERROR]"),
+      }.freeze
+
+      def self.start(execution, output:)
+        new(execution, output: output).start
+      end
+
+      def initialize(execution, output:)
+        @multi = TTY::Spinner::Multi.new(":spinner :task", output: output)
+        @multi.top_spinner.update(task: "Running")
+        execution.each { |job, result| register_spinner(job, result) }
+      end
+
+      def start
+        @multi.auto_spin
+      end
+
+    private
+
+      def register_spinner(job, result)
+        @multi.register(":spinner #{job}", **SPINNER_OPTIONS) do |spinner|
+          result.on_fulfillment!(spinner) { |_, spin| spin.success }
+                .on_rejection!(spinner) { |_, spin| spin.error }
+        end
+      end
+    end
+  end
+end

data/lib/cobra_commander/executor.rb

@@ -1,14 +1,45 @@
 # frozen_string_literal: true
 
-require_relative "executor/context"
-require_relative "executor/concurrent"
+require_relative "executor/execution"
+require_relative "executor/job"
+require_relative "executor/script"
+require_relative "executor/command"
+require_relative "executor/spinners"
+require_relative "executor/interactive_printer"
+require_relative "executor/markdown_printer"
 
 module CobraCommander
-  # Execute a command on all given components
+  # Execute a command on all given packages
   module Executor
-    def self.exec(components:, command:, concurrency:, status_output:)
-      Concurrent.new(components, concurrency: concurrency, spin_output: status_output)
-                .exec(command)
+  module_function
+
+    # Executes the given jobs in an CobraCommander::Executor::Execution.
+    #
+    # This facade also allows to execute the jobs with a spinner (@see CobraCommander::Executor::Spinners) to display
+    # the execution status of each job.
+    #
+    # You can also determine how to display the execution once it's completed, by setting `output_mode` to either
+    # :interactive or :markdown. When using :interactive, a menu with each job will be displayed allowing the user
+    # to select a job and see its output. When using :markdown, a markdown will be printed to `output` with the
+    # output of each job.
+    #
+    # @param jobs [Enumerable<CobraCommander::Executor::Job>] the jobs to run
+    # @param status_output [IO,nil] if not nil, will print the spinners for each job in this output
+    # @param workers [Integer] number of workers processing the jobs queue (see CobraCommander::Executor::Execution)
+    # @param output_mode [:interactive,:markdown,nil] how the output will be printed after execution
+    # @param workers [Integer] number of workers processing the jobs queue (see CobraCommander::Executor::Execution)
+    # @return [CobraCommander::Executor::Execution]
+    # @see CobraCommander::Executor::Execution
+    # @see CobraCommander::Executor::Spinners
+    # @see CobraCommander::Executor::InterativePrinter
+    # @see CobraCommander::Executor::MarkdownPrinter
+    def execute(jobs:, status_output: nil, output_mode: nil, output: nil, **kwargs)
+      Execution.new(jobs, **kwargs).tap do |execution|
+        Spinners.start(execution, output: status_output) if status_output
+        execution.wait
+        InteractivePrinter.run(execution, output) if output_mode == :interactive
+        MarkdownPrinter.run(execution, output) if output_mode == :markdown
+      end
     end
   end
 end

data/lib/cobra_commander/git_changed.rb

@@ -11,10 +11,11 @@ module CobraCommander
   class GitChanged
     include Enumerable
 
-    InvalidSelectionError = Class.new(StandardError)
+    Error = Class.new(StandardError)
+    InvalidSelectionError = Class.new(Error)
 
-    def initialize(repo_root, base_branch)
-      @repo_root = repo_root
+    def initialize(path, base_branch)
+      @path = path
       @base_branch = base_branch
     end
 
@@ -25,17 +26,21 @@ module CobraCommander
   private
 
     def changes
-      @changes ||= begin
-        diff, _, result = Dir.chdir(@repo_root) do
-          Open3.capture3("git", "diff", "--name-only", @base_branch)
-        end
+      @changes ||= Dir.chdir(@path) do
+        git_dir, _, result = Open3.capture3("git", "rev-parse", "--git-dir")
+        validate_result!(result)
 
-        raise InvalidSelectionError, "Specified branch #{@base_branch} could not be found" if result.exitstatus == 128
+        diff, _, result = Open3.capture3("git", "diff", "--name-only", @base_branch)
+        validate_result!(result)
 
-        diff.split("\n").map do |f|
-          File.join(@repo_root, f)
-        end
+        git_dir = Pathname.new(git_dir)
+        diff.split("\n").map { |f| git_dir.dirname.join(f) }
       end
     end
+
+    def validate_result!(result)
+      raise InvalidSelectionError, "Specified branch #{@base_branch} could not be found" if result.exitstatus == 128
+      raise Error, "Uknown git error: #{result.inspect}" if result.exitstatus > 0
+    end
   end
 end

data/lib/cobra_commander/package.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module CobraCommander
+  # A package within the
+  class Package
+    extend Forwardable
+
+    attr_reader :source, :path, :name, :dependencies
+
+    def_delegators :source, :key
+
+    def initialize(source, path:, dependencies:, name:)
+      @source = source
+      @path = path
+      @name = name
+      @dependencies = dependencies
+    end
+  end
+end