cobra_commander 1.0.1 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5f6e4d7e8d890c46aed5efff6219f669e79f64325f6f73c899cf6a0c5959088
-  data.tar.gz: 3fe47e6df4f555345c640051ff6aebf25dea8a5907507e6be4ebcc18876897c1
+  metadata.gz: da1b8808311f316b8e200895575b653357a88b92f8a1d05d833ab8f0bd55b0d5
+  data.tar.gz: 442d8ae693c4bac9f3d888a33fc4b5e1d1a5904c681dba43144284651b42abfd
 SHA512:
-  metadata.gz: 0add3576fb98e23aa8332939c2c19d7b4dd04cb82ab3d7cebb12191687fbe72e43efad27ddfa24c80d4393d63898f8f01915af1aa6a74a2331c00c1f57dc99a6
-  data.tar.gz: '03942e8553ee6163ad3703ce4be836ec2d538ea908cbd32d7fcd274a01b316a37f77407e32758c8d57043ec3e5a0b30007b7398e1c1a0d21018e245d8c2c09d6'
+  metadata.gz: '07940522fad6ad8f3220e25f654a19a34a8b61497b0f68c33c368db9926fd8f32446e4423112f91630511c447469866398b152736db79fc726e27dd96809d0c4'
+  data.tar.gz: a1e5b9db402504b0114c7cad3a65a4ba22bce8ba003269abb03a824128df5d586c1c39fde4d9132da97d71143b2b3d65bb6966dba464a8068e5193fb159aa373

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"
@@ -25,33 +23,30 @@ Gem::Specification.new do |spec|
   DESCRIPTION
   spec.homepage = "http://tech.powerhrg.com/cobra_commander/"
   spec.license = "MIT"
+  spec.required_ruby_version = ">= 3.2.0"
 
   spec.metadata["rubygems_mfa_required"] = "true"
   spec.metadata["homepage_uri"] = spec.homepage
   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 "bundler", ">= 2.4.17"
   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"
-  spec.add_development_dependency "guard-rspec"
-  spec.add_development_dependency "license_finder", ">= 7.0"
-  spec.add_development_dependency "pry"
-  spec.add_development_dependency "rake", ">= 12.3.3"
-  spec.add_development_dependency "rspec", "~> 3.5"
-  spec.add_development_dependency "rubocop", "1.30.1"
-  spec.add_development_dependency "rubocop-powerhome", ">= 0.5.0"
+  spec.add_development_dependency "aruba", "0.14.14"
+  spec.add_development_dependency "guard-rspec", "4.7.3"
+  spec.add_development_dependency "license_finder", "7.1"
+  spec.add_development_dependency "ostruct", "0.6.3"
+  spec.add_development_dependency "pry", "0.14.2"
+  spec.add_development_dependency "rake", "13.0.6"
+  spec.add_development_dependency "rspec", "3.13.0"
+  spec.add_development_dependency "rubocop", "1.82.1"
+  spec.add_development_dependency "rubocop-powerhome", "0.6.1"
 end

data/docs/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Change Log
 
+## Version 1.2.0 - 2026-06-09
+
+* Add an `around_command` extension point so plugins can enhance the shell used to run `cmd`/`exec`. `Source#around_command` wraps execution (e.g. Bundler isolation) and yields a hash of environment variables for the command (base yields `{}`, scoped per-execution via TTY). Packages delegate to their source; `Component#around_command` nests each distinct source's wrapper and yields their merged env. `exec` applies it once per component (all packages contribute, later sources win); `cmd` applies each package's own. `IsolatedPTY` is now a plain PTY command — isolation comes from the sources.
+* Raise the minimum supported Ruby version to 3.2 and expand CI to cover Ruby 4.0.
+
+## 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(&)
+      (directly | transitively).sort_by(&:name).each(&)
     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/ascii_tree.rb

@@ -43,12 +43,12 @@ module CobraCommander
 
       def add_tee(io, outdents, dep)
         io.puts line(outdents, TEE, dep.name)
-        list_dependencies(io, dep, (outdents + [BAR]))
+        list_dependencies(io, dep, outdents + [BAR])
       end
 
       def add_corner(io, outdents, dep)
         io.puts line(outdents, CORNER, dep.name)
-        list_dependencies(io, dep, (outdents + [SPACE]))
+        list_dependencies(io, dep, outdents + [SPACE])
       end
 
       def line(outdents, sym, 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,46 +38,42 @@ 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"
     def tree(component = nil)
       components = component ? [find_component(component)] : umbrella.components
-      puts Output::AsciiTree.new(components).to_s
+      puts Output::AsciiTree.new(components)
     end
 
     desc "graph [component]", "Outputs a graph 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
@@ -21,6 +25,18 @@ module CobraCommander
       @packages.map(&:path).uniq
     end
 
+    # Wraps the execution of a command on this component by nesting the
+    # around_command of each distinct source backing its packages, so every
+    # package gets a chance to enhance the surrounding process. The env vars
+    # each source yields are merged (later sources win) and the merged hash is
+    # yielded to the block.
+    #
+    # @yieldparam env [Hash{String => String}] merged env vars for the command
+    # @return the value returned by the block
+    def around_command(&)
+      nest_sources(@packages.map(&:source).uniq, {}, &)
+    end
+
     def inspect
       "#<CobraCommander::Component:#{object_id} #{name} dependencies=#{dependencies.map(&:name)} packages=#{packages}>"
     end
@@ -46,5 +62,18 @@ module CobraCommander
     def dependencies
       @dependencies ||= @dependency_names.sort.filter_map { |name| @umbrella.find(name) }
     end
+
+  private
+
+    # Nests each source's #around_command, accumulating the env each yields,
+    # and finally yields the merged env to the block.
+    def nest_sources(sources, env, &block)
+      return yield(env) if sources.empty?
+
+      head, *rest = sources
+      head.around_command do |source_env|
+        nest_sources(rest, env.merge(source_env), &block)
+      end
+    end
   end
 end

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,51 @@
 # 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]
+      # @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)
+        package.around_command do |env|
+          run_command tty, package, @command_name, env
         end
       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, env)
+        definition = package.source.config&.dig("commands", command_name)
+        case definition
+        when Array then run_multiple(tty, package, definition, env)
+        when Hash then run_with_criteria(tty, package, definition, env)
+        when nil then [:skip, format(SKIP_UNEXISTING, command_name, package.key)]
+        else run_script(tty, definition, package.path, env: env)
         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, env)
+        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, env: env)
       end
 
-      def run_multiple(package, commands)
-        Command.join(commands.map { |command| Command.new(package, command) })
+      def run_multiple(tty, package, commands, env)
+        run_many(commands) { run_command(tty, package, _1, env) }
       end
     end
   end

data/lib/cobra_commander/executor/isolated_pty.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module CobraCommander
+  module Executor
+    #
+    # A PTY-enabled TTY::Command used to execute component scripts.
+    #
+    # Per-execution environment variables are supplied to TTY::Command#run!
+    # (so they are scoped to each subprocess and never mutate the parent
+    # ENV), while environment isolation/enhancement such as Bundler's
+    # `with_unbundled_env` is contributed by the package sources through
+    # their #around_command (see CobraCommander::Ruby::Bundle).
+    #
+    class IsolatedPTY < ::TTY::Command
+      def initialize(**)
+        super(pty: true, **)
+      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