command_mapper-gen 0.1.0.pre1

data/lib/command_mapper/gen/task.rb

@@ -0,0 +1,90 @@
+require 'rake/tasklib'
+
+module CommandMapper
+  module Gen
+    #
+    # Defines a `command_mapper:gen` task which automatically generates a
+    # command class file.
+    #
+    #     require 'command_mapper/gen/task'
+    #     CommandMapper::Gen::Task.new('grep','lib/path/to/grep.rb')
+    #
+    #     $ rake command_mapper:gen
+    #
+    class Task < Rake::TaskLib
+
+      # The command name or path to the command.
+      #
+      # @return [String]
+      attr_accessor :command_name
+
+      # The output file path.
+      #
+      # @return [String]
+      attr_accessor :output
+
+      # The parser to invoke.
+      #
+      # @return [:help, :man, nil]
+      attr_accessor :parser
+
+      #
+      # Initializes the task.
+      #
+      # @param [String] command_name
+      #   The command name or path to the command.
+      #
+      # @param [String] output
+      #   The output file path.
+      #
+      # @param [:help, :man, nil] parser
+      #   The optional parser to target.
+      #
+      # @yield [task]
+      #   If a block is given, it will be yielded to before the rake task has
+      #   been defined.
+      #
+      # @yieldparam [Task] task
+      #   The newly created task.
+      #
+      def initialize(command_name,output, parser: nil)
+        @command_name = command_name
+        @output       = output
+
+        @parser = parser
+
+        yield self if block_given?
+        define
+      end
+
+      #
+      # Defines the `command_mapper:gen` task and output file's task.
+      #
+      def define
+        output_dir = File.dirname(@output)
+
+        directory(output_dir)
+        file(@output => output_dir) do
+          generate
+        end
+
+        desc "Generates the #{@output} file"
+        task 'command_mapper:gen' => @output
+      end
+
+      #
+      # Generates the {#output} file.
+      #
+      def generate
+        args = ["--output", @output]
+
+        if @parser
+          args << '--parser' << @parser.to_s
+        end
+
+        sh "command_mapper-gen", *args, @command_name
+      end
+
+    end
+  end
+end

data/lib/command_mapper/gen/types/enum.rb

@@ -0,0 +1,30 @@
+module CommandMapper
+  module Gen
+    module Types
+      class Enum
+
+        # @return [Array<Symbol>]
+        attr_reader :values
+
+        #
+        # Initializes the enum type.
+        #
+        # @param [Array<Symbol>] values
+        #
+        def initialize(values)
+          @values = values
+        end
+
+        #
+        # Converts the map type to Ruby source code.
+        #
+        # @return [String]
+        #
+        def to_ruby
+          "Enum[#{@values.map(&:inspect).join(', ')}]"
+        end
+
+      end
+    end
+  end
+end

data/lib/command_mapper/gen/types/key_value.rb

@@ -0,0 +1,34 @@
+module CommandMapper
+  module Gen
+    module Types
+      class KeyValue
+
+        # @return [String]
+        attr_reader :separator
+
+        #
+        # Initializes the key-value type.
+        #
+        # @param [String] separator
+        #   The separator character.
+        #
+        def initialize(separator: '=')
+          @separator = separator
+        end
+
+        #
+        # Converts the key-value type to Ruby source code.
+        #
+        # @return [String]
+        #
+        def to_ruby
+          ruby = "KeyValue.new("
+          ruby << "separator: #{@separator.inspect}" unless @separator == '='
+          ruby << ")"
+          ruby
+        end
+
+      end
+    end
+  end
+end

data/lib/command_mapper/gen/types/list.rb

@@ -0,0 +1,34 @@
+module CommandMapper
+  module Gen
+    module Types
+      class List
+
+        # @return [String]
+        attr_reader :separator
+
+        #
+        # Initializes the list type.
+        #
+        # @param [String] separator
+        #   The separator character.
+        #
+        def initialize(separator: ',')
+          @separator = separator
+        end
+
+        #
+        # Converts the list type to Ruby source code.
+        #
+        # @return [String]
+        #
+        def to_ruby
+          ruby = "List.new("
+          ruby << "separator: #{@separator.inspect}" unless @separator == ','
+          ruby << ")"
+          ruby
+        end
+
+      end
+    end
+  end
+end

data/lib/command_mapper/gen/types/map.rb

@@ -0,0 +1,36 @@
+module CommandMapper
+  module Gen
+    module Types
+      class Map
+
+        # @return [Hash{Object => String}]
+        attr_reader :map
+
+        #
+        # Initializes the map type.
+        #
+        # @param [Hash{Object => String}] map
+        #
+        def initialize(map)
+          @map = map
+        end
+
+        #
+        # Converts the map type to Ruby source code.
+        #
+        # @return [String]
+        #
+        def to_ruby
+          pairs = []
+
+          @map.each do |value,string|
+            pairs << "#{value.inspect} => #{string.inspect}"
+          end
+
+          return "Map.new(#{pairs.join(', ')})"
+        end
+
+      end
+    end
+  end
+end

data/lib/command_mapper/gen/types/num.rb

@@ -0,0 +1,18 @@
+module CommandMapper
+  module Gen
+    module Types
+      class Num
+
+        #
+        # Converts the num type to Ruby source code.
+        #
+        # @return [String]
+        #
+        def to_ruby
+          "Num.new"
+        end
+
+      end
+    end
+  end
+end

data/lib/command_mapper/gen/types/str.rb

@@ -0,0 +1,48 @@
+module CommandMapper
+  module Gen
+    module Types
+      class Str
+
+        # The `allow_empty` keyword.
+        #
+        # @return [Boolean, nil]
+        attr_reader :allow_empty
+
+        # The `allow_blank` keyword.
+        #
+        # @return [Boolean, nil]
+        attr_reader :allow_blank
+
+        #
+        # Initializes the value type.
+        #
+        # @param [Boolean, nil] allow_empty
+        #   The `allow_empty` keyword value.
+        #
+        # @param [Boolean, nil] allow_blank
+        #   The `allow_blank` keyword value.
+        #
+        def initialize(allow_empty: nil, allow_blank: nil)
+          @allow_empty = allow_empty
+          @allow_blank = allow_blank
+        end
+
+        #
+        # Converts the value type to Ruby source code.
+        #
+        # @return [String, nil]
+        #
+        def to_ruby
+          unless (@allow_empty.nil? && @allow_blank.nil?)
+            keywords = []
+
+            keywords << "allow_empty: #{@allow_empty.inspect}" unless @allow_empty.nil?
+            keywords << "allow_blank: #{@allow_blank.inspect}" unless @allow_blank.nil?
+            keywords.join(', ')
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/command_mapper/gen/types.rb

@@ -0,0 +1,6 @@
+require 'command_mapper/gen/types/str'
+require 'command_mapper/gen/types/num'
+require 'command_mapper/gen/types/list'
+require 'command_mapper/gen/types/key_value'
+require 'command_mapper/gen/types/map'
+require 'command_mapper/gen/types/enum'

data/lib/command_mapper/gen/version.rb

@@ -0,0 +1,6 @@
+module CommandMapper
+  module Gen
+    # Version of command_mapper-gen
+    VERSION = '0.1.0.pre1'
+  end
+end

data/lib/command_mapper/gen.rb

@@ -0,0 +1,2 @@
+require 'command_mapper/gen/command'
+require 'command_mapper/gen/parsers'

data/spec/argument_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+require 'command_mapper/gen/argument'
+require 'command_mapper/gen/types/str'
+require 'command_mapper/gen/types/num'
+
+describe CommandMapper::Gen::Argument do
+  let(:name) { :arg1 }
+
+  subject { described_class.new(name) }
+
+  describe "#initialize" do
+    it "must set #name" do
+      expect(subject.name).to eq(name)
+    end
+
+    it "must default #type to nil" do
+      expect(subject.type).to be(nil)
+    end
+
+    it "must default #repeats to nil" do
+      expect(subject.repeats).to be(nil)
+    end
+
+    context "when given the value: keyword argument" do
+      context "and it's a Types object" do
+        let(:type) { Types::Num.new }
+
+        subject { described_class.new(name, type: type) }
+
+        it "must set #type" do
+          expect(subject.type).to be(type)
+        end
+      end
+    end
+
+    context "when given the repeats: keyword argument" do
+      let(:repeats) { true }
+
+      subject { described_class.new(name, repeats: repeats) }
+
+      it "must set #repeats" do
+        expect(subject.repeats).to eq(repeats)
+      end
+    end
+  end
+
+  describe "#to_ruby" do
+    it "must output 'argument \#{name}'" do
+      expect(subject.to_ruby).to eq("argument #{name.inspect}")
+    end
+
+    context "when #required is true" do
+      let(:required) { true}
+
+      subject { described_class.new(name, required: required) }
+
+      it "must not append 'required: true'" do
+        expect(subject.to_ruby).to eq("argument #{name.inspect}")
+      end
+    end
+
+    context "when #required is false" do
+      let(:required) { false }
+
+      subject { described_class.new(name, required: required) }
+
+      it "must append 'required: false'" do
+        expect(subject.to_ruby).to eq("argument #{name.inspect}, required: #{required.inspect}")
+      end
+    end
+
+    context "when #type is not nil" do
+      let(:type) { Types::Num.new }
+
+      subject { described_class.new(name, type: type) }
+
+      it "must append 'type: ...' and call the #type's #to_ruby method" do
+        expect(subject.to_ruby).to eq("argument #{name.inspect}, type: #{type.to_ruby}")
+      end
+    end
+
+    context "when #repeats is true" do
+      let(:repeats) { true }
+
+      subject { described_class.new(name, repeats: repeats) }
+
+      it "must append 'repeats: true'" do
+        expect(subject.to_ruby).to eq("argument #{name.inspect}, repeats: #{repeats.inspect}")
+      end
+    end
+  end
+end

data/spec/cli_spec.rb

@@ -0,0 +1,269 @@
+require 'spec_helper'
+require 'command_mapper/gen/cli'
+
+describe CommandMapper::Gen::CLI do
+  describe "#initialize" do
+    it "must default #output to nil" do
+      expect(subject.output).to be(nil)
+    end
+
+    it "must default #parsers to [Parsers::Help, Parsers::Man]" do
+      expect(subject.parsers).to eq([Parsers::Help, Parsers::Man])
+    end
+
+    it "must default #command to nil" do
+      expect(subject.command).to be(nil)
+    end
+
+    it "must initialize #option_parser" do
+      expect(subject.option_parser).to be_kind_of(OptionParser)
+    end
+
+    it "must set #debug to false" do
+      expect(subject.debug).to be(false)
+    end
+  end
+
+  describe ".run" do
+    subject { described_class }
+
+    context "when Interrupt is raised" do
+      before do
+        expect_any_instance_of(described_class).to receive(:run).and_raise(Interrupt)
+      end
+
+      it "must exit with 130" do
+        expect(subject.run([])).to eq(130)
+      end
+    end
+
+    context "when Errno::EPIPE is raised" do
+      before do
+        expect_any_instance_of(described_class).to receive(:run).and_raise(Errno::EPIPE)
+      end
+
+      it "must exit with 0" do
+        expect(subject.run([])).to eq(0)
+      end
+    end
+  end
+
+  describe "#run" do
+    let(:command_name) { 'yes' }
+
+    let(:expected_output) do
+      [
+        "require 'command_mapper/command'",
+        "",
+        "#",
+        "# Represents the `#{command_name}` command",
+        "#",
+        "class #{command_name.capitalize} < CommandMapper::Command",
+        "",
+        "  command \"#{command_name}\" do",
+        "    option \"--help\"",
+        "    option \"--version\"",
+        "",
+        "    argument :string, required: false, repeats: true",
+        "  end",
+        "",
+        "end",
+      ].join($/) + $/
+    end
+
+    context "when given a COMMAND_NAME" do
+      let(:argv) { [command_name] }
+
+      it "must parse the command's --help and/or man page and print ruby code" do
+        expect {
+          subject.run(argv)
+        }.to output(expected_output).to_stdout
+      end
+
+      context "but the command isn't installed" do
+        before do
+          allow(CommandMapper::Gen::Parsers::Help).to receive(:`).with("#{command_name} --help 2>&1").and_raise(Errno::ENOENT.new(command_name))
+        end
+
+        it "must print an error and exit with -1" do
+          expect {
+            expect(subject.run(argv)).to eq(-1)
+          }.to output("#{described_class::PROGRAM_NAME}: command #{command_name.inspect} is not installed#{$/}").to_stderr
+        end
+      end
+    end
+
+    context "when an invalid option is given" do
+      let(:option) { "--foo"  }
+      let(:argv)   { [option] }
+
+      it "must print an error message and return -1" do
+        expect {
+          expect(subject.run(argv)).to eq(-1)
+        }.to output("#{described_class::PROGRAM_NAME}: invalid option: #{option}#{$/}").to_stderr
+      end
+    end
+
+    context "when the command's --help and -h output are empty" do
+      let(:argv) { %w[true] }
+
+      it "must print an error message and return -2" do
+        expect {
+          expect(subject.run(argv)).to eq(-2)
+        }.to output("#{described_class::PROGRAM_NAME}: no options or arguments detected#{$/}").to_stderr
+      end
+    end
+
+    context "when no arguments are given" do
+      let(:argv) { [] }
+
+      it "must print an error message and return -1" do
+        expect {
+          expect(subject.run(argv)).to eq(-1)
+        }.to output("#{described_class::PROGRAM_NAME}: expects a COMMAND_NAME#{$/}").to_stderr
+      end
+    end
+  end
+
+  describe "#option_parser" do
+    context "when given -o FILE" do
+      let(:file) { "/path/to/file.rb" }
+      let(:argv) { ['-o', file] }
+
+      before { subject.option_parser.parse(argv) }
+
+      it "must set #output to the FILE" do
+        expect(subject.output).to eq(file)
+      end
+    end
+
+    context "when given --output FILE" do
+      let(:file) { "/path/to/file.rb" }
+      let(:argv) { ['--output', file] }
+
+      before { subject.option_parser.parse(argv) }
+
+      it "must set #output to the FILE" do
+        expect(subject.output).to eq(file)
+      end
+    end
+
+    context "when givne -p help" do
+      let(:argv) { ['-p', "help"] }
+
+      before { subject.option_parser.parse(argv) }
+
+      it "must set #parsers to [Parser::Help]" do
+        expect(subject.parsers).to eq([Parsers::Help])
+      end
+    end
+
+    context "when givne -p man" do
+      let(:argv) { ['-p', "man"] }
+
+      before { subject.option_parser.parse(argv) }
+
+      it "must set #parsers to [Parser::Man]" do
+        expect(subject.parsers).to eq([Parsers::Man])
+      end
+    end
+
+    context "when givne --parser help" do
+      let(:argv) { ['--parser', "help"] }
+
+      before { subject.option_parser.parse(argv) }
+
+      it "must set #parsers to [Parser::Help]" do
+        expect(subject.parsers).to eq([Parsers::Help])
+      end
+    end
+
+    context "when givne --parser man" do
+      let(:argv) { ['--parser', "man"] }
+
+      before { subject.option_parser.parse(argv) }
+
+      it "must set #parsers to [Parser::Man]" do
+        expect(subject.parsers).to eq([Parsers::Man])
+      end
+    end
+
+    context "when given -d" do
+      let(:argv) { ['-d'] }
+
+      before { subject.option_parser.parse(argv) }
+
+      it "must set #debug to true" do
+        expect(subject.debug).to be(true)
+      end
+    end
+
+    context "when given --debug" do
+      let(:argv) { ['--debug'] }
+
+      before { subject.option_parser.parse(argv) }
+
+      it "must set #debug to true" do
+        expect(subject.debug).to be(true)
+      end
+    end
+
+    context "when given -V" do
+      let(:argv) { ["-v"] }
+
+      it "must print the command name and version, then exit" do
+        expect(subject).to receive(:exit)
+
+        expect {
+          subject.option_parser.parse(argv)
+        }.to output("#{described_class::PROGRAM_NAME} #{VERSION}#{$/}").to_stdout
+      end
+    end
+
+    context "when given --version" do
+      let(:argv) { ["--version"] }
+
+      it "must print the command name and version, then exit" do
+        expect(subject).to receive(:exit)
+
+        expect {
+          subject.option_parser.parse(argv)
+        }.to output("#{described_class::PROGRAM_NAME} #{VERSION}#{$/}").to_stdout
+      end
+    end
+
+    context "when given -h" do
+      let(:argv) { ["-h"] }
+
+      it "must print help text and then exit" do
+        expect(subject).to receive(:exit)
+
+        expect {
+          subject.option_parser.parse(argv)
+        }.to output("#{subject.option_parser}").to_stdout
+      end
+    end
+
+    context "when given --help" do
+      let(:argv) { ["-h"] }
+
+      it "must print help text and then exit" do
+        expect(subject).to receive(:exit)
+
+        expect {
+          subject.option_parser.parse(argv)
+        }.to output("#{subject.option_parser}").to_stdout
+      end
+    end
+  end
+
+  describe "#print_error" do
+    let(:message) { "error!" }
+
+    it "must print the command name and the message to stderr" do
+      expect {
+        subject.print_error(message)
+      }.to output("#{described_class::PROGRAM_NAME}: #{message}#{$/}").to_stderr
+    end
+  end
+end