Allow command initializer to accept a block that can be run with #run, and refactor CLI to parse command line arguments/flags/switches into Command::Option

Author: codenamev

lib/git_commander/cli.rb

@@ -44,8 +44,8 @@ def say(message)
     #
     # @param command [Command] the git-cmd command to parse the arguments for
     # @param arguments [Array] the command line arguments
+    # @return options [Array] the GitCommander::Command options with values
     def parse_command_options!(command, arguments)
-      options = {}
       valid_arguments_for_command = command.arguments.map { |arg| "[#{arg.name}]" }.join(" ")
 
       parser = OptionParser.new do |opts|
@@ -54,29 +54,25 @@ def parse_command_options!(command, arguments)
         opts.separator  "COMMAND OPTIONS:" if command.flags.any? || command.switches.any?
 
         command.flags.each do |flag|
-          opts.on("-#{flag.name[0]}", "--#{underscore_to_kebab(flag.name)} #{flag.name.upcase}", flag.description.to_s) do |f|
-            options[flag.name] = f || flag.default
+          opts.on("-#{flag.name[0]}", command_line_flag_formatted_name(flag), flag.description.to_s) do |f|
+            flag.value = f
           end
         end
 
         command.switches.each do |switch|
           opts.on("-#{switch.name[0]}", "--[no-]#{switch.name}", switch.description) do |s|
-            options[switch.name] = s || switch.default
+            switch.value = s
           end
         end
       end
       parser.parse!(arguments)
 
       # Add arguments to options to pass to defined commands
       command.arguments.each do |argument|
-        options[argument.name] = arguments.shift || argument.default
-      end
-      # Add any defaults
-      (command.flags + command.switches).each do |option|
-        options[option.name] ||= option.default
+        argument.value = arguments.shift
       end
 
-      options
+      command.options
     rescue OptionParser::InvalidOption, OptionParser::MissingArgument => e
       command.help
       GitCommander.logger.debug "[CLI] Failed to parse command line options – #{e.inspect}"
@@ -85,6 +81,10 @@ def parse_command_options!(command, arguments)
 
     private
 
+    def command_line_flag_formatted_name(flag)
+      "--#{underscore_to_kebab(flag.name)} #{flag.name.upcase}"
+    end
+
     def underscore_to_kebab(sym_or_string)
       sym_or_string.to_s.gsub("_", "-").to_sym
     end

lib/git_commander/command.rb

@@ -3,18 +3,24 @@
 module GitCommander
   # @abstract Wraps domain logic for executing git-cmd commands
   class Command
-    attr_reader :arguments, :block, :description, :flags, :name, :summary, :switches
+    attr_reader :arguments, :block, :description, :flags, :name, :options, :summary, :switches
     attr_accessor :output
 
     # @nodoc
     class Option
       attr_reader :default, :description, :name
+      attr_writer :value
+
       def initialize(name:, default: nil, description: nil)
         @name = name.to_sym
         @default = default
         @description = description
       end
 
+      def value
+        @value || @default
+      end
+
       def ==(other)
         other.class == self.class &&
           other.name == name &&
@@ -24,19 +30,20 @@ def ==(other)
       alias eql? ==
     end
 
-    def initialize(name, registry: nil, **options)
+    def initialize(name, registry: nil, **options, &block)
       @name = name
       @description = options[:description]
       @summary = options[:summary]
-      @block = options[:block] || proc {}
+      @block = block_given? ? block : proc {}
       @registry = registry || GitCommander::Registry.new
       @output = options[:output] || STDOUT
 
-      parse_options(options)
+      define_command_options(options)
     end
 
-    def run(args = [])
-      GitCommander.logger.info "Running '#{name}' with arguments: #{args.inspect}"
+    def run(run_options = [])
+      GitCommander.logger.info "Running '#{name}' with arguments: #{@options.inspect}"
+      instance_exec(run_options, &@block)
     end
 
     def say(message)
@@ -55,10 +62,15 @@ def help
 
     private
 
-    def parse_options(options)
-      @arguments = Array(options[:arguments]).map { |a| Option.new(**a) }
-      @flags = Array(options[:flags]).map { |f| Option.new(**f) }
-      @switches = Array(options[:switches]).map { |s| Option.new(**s) }
+    def define_command_options(options)
+      @arguments = options_from_hash(options[:arguments])
+      @flags = options_from_hash(options[:flags])
+      @switches = options_from_hash(options[:switches])
+      @options = Set.new(@arguments + @flags + @switches)
+    end
+
+    def options_from_hash(hash)
+      Array(hash).map { |v| Option.new(**v) }
     end
 
     def description_help

spec/lib/git_commander/cli_spec.rb

@@ -45,8 +45,11 @@
     target_command = "wtf"
     arguments = ["What's up with that?", "And this?"]
     command = GitCommander::Command.new :zombie, arguments: [{ name: :this }, { name: :that }], output: output
+    expected_comand_options = command.options.dup
+    expected_comand_options.find { |o| o.name == :this }.value = arguments.first
+    expected_comand_options.find { |o| o.name == :that }.value = arguments.last
     expect(registry).to receive(:find).with(target_command).and_return(command)
-    expect(command).to receive(:run).with(this: arguments.first, that: arguments.last)
+    expect(command).to receive(:run).with(expected_comand_options)
     expect(cli).to_not receive(:help)
 
     cli.run [target_command, *arguments]
@@ -58,8 +61,10 @@
       flags: [{ name: :question, default: "What's up with that?" }],
       output: output
     )
+    expected_comand_options = command.options.dup
+    expected_comand_options.find { |o| o.name == :question }.value = "Yo dawg, zombies?"
     expect(registry).to receive(:find).with("zombie").and_return(command)
-    expect(command).to receive(:run).with(question: "Yo dawg, zombies?")
+    expect(command).to receive(:run).with(expected_comand_options)
     expect(cli).to_not receive(:help)
 
     cli.run ["zombie", "--question", "Yo dawg, zombies?"]
@@ -71,8 +76,9 @@
       flags: [{ name: :question, default: "What's up with that?" }],
       output: output
     )
+    expected_comand_options = command.options.dup
     expect(registry).to receive(:find).with("zombie").and_return(command)
-    expect(command).to receive(:run).with(question: "What's up with that?")
+    expect(command).to receive(:run).with(expected_comand_options)
     expect(cli).to_not receive(:help)
 
     cli.run ["zombie"]
@@ -87,13 +93,13 @@
       switches: [{ name: :auto_answer, default: false }],
       output: output
     )
+    expected_comand_options = command.options.dup
+    expected_comand_options.find { |o| o.name == :this }.value = arguments.first
+    expected_comand_options.find { |o| o.name == :that }.value = arguments.last
+    expected_comand_options.find { |o| o.name == :question }.value = "Yo dawg, zombies?"
+    expected_comand_options.find { |o| o.name == :auto_answer }.value = true
     expect(registry).to receive(:find).with("zombie").and_return(command)
-    expect(command).to receive(:run).with(
-      this: arguments.first,
-      that: arguments.last,
-      question: "Yo dawg, zombies?",
-      auto_answer: true
-    )
+    expect(command).to receive(:run).with(expected_comand_options)
     expect(cli).to_not receive(:help)
 
     cli.run ["zombie", "-q", "Yo dawg, zombies?", "--auto-answer", *arguments]

spec/lib/git_commander/command_spec.rb

@@ -3,18 +3,36 @@
 require "spec_helper"
 
 describe GitCommander::Command do
-  it "runs the block registered to it"
-  it "runs the block registered to it passing arguments"
+  it "runs the block registered to it" do
+    output = spy("output")
+    command = described_class.new(:wtf, output: output) do
+      say "I'm on a boat!"
+    end
+    command.run
+    expect(output).to have_received(:puts).with "I'm on a boat!"
+  end
+
+  it "runs the block registered to it passing arguments" do
+    output = spy("output")
+    command = described_class.new(:wtf, output: output) do |vehicle:|
+      say "I'm on a #{vehicle}!"
+    end
+    command.run vehicle: "T-Rex"
+    expect(output).to have_received(:puts).with "I'm on a T-Rex!"
+  end
   it "runs the block registered to it passing options"
   it "runs the block registered to it passing arguments and options"
   it "runs the block registered to it passing options with defaults"
+
   it "can add output" do
     output = spy("output")
     command = described_class.new(:wtf, output: output)
     command.say "Ooh eeh what's up with that"
     expect(output).to have_received(:puts).with "Ooh eeh what's up with that"
   end
 
+  it "raises an error if no arguments, flags, or switches exist for the params passed"
+
   it "can output a help message" do
     output = spy("output")
     full_command = described_class.new(