command_mapper 0.1.1 → 0.2.1

data/spec/option_spec.rb

@@ -41,6 +41,14 @@ describe CommandMapper::Option do
       end
     end
 
+    context "when value_in_flag: true is given" do
+      subject { described_class.new(flag, value_in_flag: true) }
+
+      it "#value_in_flag? must return true" do
+        expect(subject.value_in_flag?).to be(true)
+      end
+    end
+
     context "when given the repeats: true keyword argument" do
       subject { described_class.new(flag, repeats: true) }
 
@@ -177,6 +185,97 @@ describe CommandMapper::Option do
     end
   end
 
+  describe "#accepts_value?" do
+    context "when initialized with the value: keyword argument" do
+      context "and when value: is true" do
+        subject { described_class.new(flag, value: true) }
+
+        it "must return true" do
+          expect(subject.accepts_value?).to be(true)
+        end
+      end
+
+      context "and when value: is a Hash" do
+        let(:value_required) { true }
+        let(:value_type)     { Types::KeyValue.new }
+        let(:value_kwargs) do
+          {
+            required: value_required,
+            type:     value_type
+          }
+        end
+
+        subject { described_class.new(flag, value: value_kwargs) }
+
+        it "must return true" do
+          expect(subject.accepts_value?).to be(true)
+        end
+      end
+    end
+
+    context "when not initialied with the value: keyword argument" do
+      subject { described_class.new(flag) }
+
+      it "must return false" do
+        expect(subject.accepts_value?).to be(false)
+      end
+    end
+  end
+
+  describe "#equals?" do
+    context "when initialized with equals: true" do
+      subject { described_class.new(flag, value: true, equals: true) }
+
+      it "must return true" do
+        expect(subject.equals?).to be(true)
+      end
+    end
+
+    context "when not initialized with equals: true" do
+      subject { described_class.new(flag, value: true) }
+
+      it "must return nil" do
+        expect(subject.equals?).to be(nil)
+      end
+    end
+  end
+
+  describe "#repeats?" do
+    context "when initialized with repeats: true" do
+      subject { described_class.new(flag, value: true, repeats: true) }
+
+      it "must return true" do
+        expect(subject.repeats?).to be(true)
+      end
+    end
+
+    context "when not initialized with repeats: true" do
+      subject { described_class.new(flag, value: true) }
+
+      it "must return false" do
+        expect(subject.repeats?).to be(false)
+      end
+    end
+  end
+
+  describe "#value_in_flag?" do
+    context "when initialized with value_in_flag: true" do
+      subject { described_class.new(flag, value: true, value_in_flag: true) }
+
+      it "must return true" do
+        expect(subject.value_in_flag?).to be(true)
+      end
+    end
+
+    context "when not initialized with value_in_flag: true" do
+      subject { described_class.new(flag, value: true) }
+
+      it "must return nil" do
+        expect(subject.value_in_flag?).to be(nil)
+      end
+    end
+  end
+
   let(:flag) { "--opt" }
   let(:name) { "opt" }
 
@@ -199,11 +298,17 @@ describe CommandMapper::Option do
     }
   end
 
+  let(:equals) { nil }
+  let(:value_in_flag) { nil }
+
   subject do
     if accepts_value
       described_class.new(flag, name:    name,
                                 value:   value_kwargs,
-                                repeats: repeats)
+                                repeats: repeats,
+                                # formatting options
+                                equals:        equals,
+                                value_in_flag: value_in_flag)
     else
       described_class.new(flag, name: name, repeats: repeats)
     end
@@ -516,6 +621,34 @@ describe CommandMapper::Option do
               )
             end
 
+            context "and #equals? is true" do
+              let(:equals) { true }
+
+              it "must return an argv of option flag=value Strings" do
+                expect(subject.argv(values)).to eq(
+                  [
+                    "#{flag}=#{values[0]}",
+                    "#{flag}=#{values[1]}",
+                    "#{flag}=#{values[2]}"
+                  ]
+                )
+              end
+            end
+
+            context "and #value_in_flag? is true" do
+              let(:value_in_flag) { true }
+
+              it "must return an argv of option flag + value Strings" do
+                expect(subject.argv(values)).to eq(
+                  [
+                    "#{flag}#{values[0]}",
+                    "#{flag}#{values[1]}",
+                    "#{flag}#{values[2]}"
+                  ]
+                )
+              end
+            end
+
             context "but one of the Array's elements is invalid" do
               let(:value) { ["foo", " ", "baz"] }
 
@@ -578,6 +711,32 @@ describe CommandMapper::Option do
                 )
               end
 
+              context "and #equals? is true" do
+                let(:equals) { true }
+
+                it "must return an argv of option flag=value Strings" do
+                  expect(subject.argv(values)).to eq(
+                    [
+                      "#{flag}=#{subject.value.format(values[0])}",
+                      "#{flag}=#{subject.value.format(values[1])}"
+                    ]
+                  )
+                end
+              end
+
+              context "and #value_in_flag? is true" do
+                let(:value_in_flag) { true }
+
+                it "must return an argv of option flag + value Strings" do
+                  expect(subject.argv(values)).to eq(
+                    [
+                      "#{flag}#{subject.value.format(values[0])}",
+                      "#{flag}#{subject.value.format(values[1])}"
+                    ]
+                  )
+                end
+              end
+
               context "but one of the Hashes is empty" do
                 let(:values) do
                   [{"foo" => 1}, {}]
@@ -621,6 +780,22 @@ describe CommandMapper::Option do
               expect(subject.argv(value)).to eq([flag, value])
             end
 
+            context "and #equals? is true" do
+              let(:equals) { true }
+
+              it "must return an argv containing an option flag=value String" do
+                expect(subject.argv(value)).to eq(["#{flag}=#{value}"])
+              end
+            end
+
+            context "and #value_in_flag? is true" do
+              let(:value_in_flag) { true }
+
+              it "must return an argv containing an option flag + value String" do
+                expect(subject.argv(value)).to eq(["#{flag}#{value}"])
+              end
+            end
+
             context "but it's invalid" do
               let(:value) { " " }
 
@@ -656,6 +831,26 @@ describe CommandMapper::Option do
                 )
               end
 
+              context "and #equals? is true" do
+                let(:equals) { true }
+
+                it "must return an argv containing an option flag=value String" do
+                  expect(subject.argv(value)).to eq(
+                    ["#{flag}=#{subject.value.format(value)}"]
+                  )
+                end
+              end
+
+              context "and #value_in_flag? is true" do
+                let(:value_in_flag) { true }
+
+                it "must return an argv of option flag + value Strings" do
+                  expect(subject.argv(value)).to eq(
+                    ["#{flag}#{subject.value.format(value)}"]
+                  )
+                end
+              end
+
               context "but it's empty" do
                 let(:value) { {} }
 
@@ -704,6 +899,22 @@ describe CommandMapper::Option do
             expect(subject.argv(value)).to eq([flag, value])
           end
 
+          context "and #equals? is true" do
+            let(:equals) { true }
+
+            it "must return an argv containing an option flag=value String" do
+              expect(subject.argv(value)).to eq(["#{flag}=#{value}"])
+            end
+          end
+
+          context "and #value_in_flag? is true" do
+            let(:value_in_flag) { true }
+
+            it "must return an argv containing an option flag + value String" do
+              expect(subject.argv(value)).to eq(["#{flag}#{value}"])
+            end
+          end
+
           context "but it's invalid" do
             let(:value) { " " }
 
@@ -743,6 +954,26 @@ describe CommandMapper::Option do
               )
             end
 
+            context "and #equals? is true" do
+              let(:equals) { true }
+
+              it "must return an argv containing an option flag=value String" do
+                expect(subject.argv(value)).to eq(
+                  ["#{flag}=#{subject.value.format(value)}"]
+                )
+              end
+            end
+
+            context "and #value_in_flag? is true" do
+              let(:value_in_flag) { true }
+
+              it "must return an argv containing an option flag + value String" do
+                expect(subject.argv(value)).to eq(
+                  ["#{flag}#{subject.value.format(value)}"]
+                )
+              end
+            end
+
             context "but one of the Array's elements is nil" do
               let(:value) { ["foo", nil, "baz"] }
 
@@ -795,6 +1026,26 @@ describe CommandMapper::Option do
               )
             end
 
+            context "and #equals? is true" do
+              let(:equals) { true }
+
+              it "must return an argv containing an option flag=value String" do
+                expect(subject.argv(value)).to eq(
+                  ["#{flag}=#{subject.value.format(value)}"]
+                )
+              end
+            end
+
+            context "and #value_in_flag? is true" do
+              let(:value_in_flag) { true }
+
+              it "must return an argv of option flag + value Strings" do
+                expect(subject.argv(value)).to eq(
+                  ["#{flag}#{subject.value.format(value)}"]
+                )
+              end
+            end
+
             context "but it's empty" do
               let(:value) { {} }
 

data/spec/option_value_spec.rb

@@ -1,8 +1,36 @@
 require 'spec_helper'
 require 'command_mapper/option_value'
+require 'command_mapper/types/num'
 require 'command_mapper/types/list'
 
 describe CommandMapper::OptionValue do
+  describe "#validate" do
+    let(:type) { Types::Num.new }
+
+    subject { described_class.new(type: type) }
+
+    context "when the option value is not required" do
+      subject do
+        described_class.new(type: type, required: false)
+      end
+
+      context "and given a value of true" do
+        it "must return true" do
+          expect(subject.validate(true)).to be(true)
+        end
+      end
+    end
+
+    context "otherwise" do
+      it "must validate the value using #type.validate" do
+        expect(subject.validate('1234')).to be(true)
+        expect(subject.validate('foo')).to eq(
+          [false, "contains non-numeric characters (\"foo\")"]
+        )
+      end
+    end
+  end
+
   describe "#format" do
     let(:type) { Types::List.new }
 

data/spec/types/hex_spec.rb

@@ -14,6 +14,16 @@ describe CommandMapper::Types::Hex do
         expect(subject.leading_zero?).to be(true)
       end
     end
+
+    context "when initialized with range: ..." do
+      let(:range) { 1..10 }
+
+      subject { described_class.new(range: range) }
+
+      it "must set #range" do
+        expect(subject.range).to eq(range)
+      end
+    end
   end
 
   describe "#leading_zero?" do
@@ -69,12 +79,60 @@ describe CommandMapper::Types::Hex do
           expect(subject.validate(value)).to be(true)
         end
 
+        context "when initialized with range: ..." do
+          let(:range) { 2..16 }
+
+          subject { described_class.new(range: range) }
+
+          context "and the value is within the range of values" do
+            let(:value) { 'a' }
+
+            it "must return true" do
+              expect(subject.validate(value)).to be(true)
+            end
+          end
+
+          context "but the value is not within the range of values" do
+            let(:value) { '0' }
+
+            it "must return [false, \"unacceptable value (...)\"]" do
+              expect(subject.validate(value)).to eq(
+                [false, "unacceptable value (#{value.inspect})"]
+              )
+            end
+          end
+        end
+
         context "and the String begins with a '0x'" do
           let(:value) { "0xabcdef" }
 
           it "must return true" do
             expect(subject.validate(value)).to be(true)
           end
+
+          context "when initialized with range: ..." do
+            let(:range) { 2..16 }
+
+            subject { described_class.new(range: range) }
+
+            context "and the value is within the range of values" do
+              let(:value) { '0x4' }
+
+              it "must return true" do
+                expect(subject.validate(value)).to be(true)
+              end
+            end
+
+            context "but the value is not within the range of values" do
+              let(:value) { '0x0' }
+
+              it "must return [false, \"unacceptable value (...)\"]" do
+                expect(subject.validate(value)).to eq(
+                  [false, "unacceptable value (#{value.inspect})"]
+                )
+              end
+            end
+          end
         end
 
         context "and the String contains a newline" do
@@ -88,7 +146,7 @@ describe CommandMapper::Types::Hex do
         end
       end
 
-      context "but the String does not contain other characters" do
+      context "but the String contains other characters" do
         let(:value) { "foo" }
 
         it "must return [false, \"not in hex format (...)\"]" do

data/spec/types/map_spec.rb

@@ -41,9 +41,9 @@ describe CommandMapper::Types::Map do
     context "when given a value that is not in the map" do
       let(:value) { 42 }
 
-      it "must return [false, \"unknown value (...)\"]" do
+      it "must return [false, \"unknown value (...) must be ..., or ...\"]" do
         expect(subject.validate(value)).to eq(
-          [false, "unknown value (#{value.inspect})"]
+          [false, "unknown value (#{value.inspect}) must be #{subject.map.keys.map(&:inspect).join(', ')}, or #{subject.map.values.map(&:inspect).join(', ')}"]
         )
       end
     end

data/spec/types/num_spec.rb

@@ -2,6 +2,24 @@ require 'spec_helper'
 require 'command_mapper/types/num'
 
 describe CommandMapper::Types::Num do
+  describe "#initialize" do
+    context "when initialized with no keyword arguments" do
+      it "must set #range to nil" do
+        expect(subject.range).to be(nil)
+      end
+    end
+
+    context "when initialized with range: ..." do
+      let(:range) { 1..10 }
+
+      subject { described_class.new(range: range) }
+
+      it "must set #range" do
+        expect(subject.range).to eq(range)
+      end
+    end
+  end
+
   describe "#validate" do
     context "when given an Integer" do
       let(:value) { 1 }
@@ -9,6 +27,30 @@ describe CommandMapper::Types::Num do
       it "must return true" do
         expect(subject.validate(value)).to be(true)
       end
+
+      context "when initialized with range: ..." do
+        let(:range) { 2..10 }
+
+        subject { described_class.new(range: range) }
+
+        context "and the value is within the range of values" do
+          let(:value) { 4 }
+
+          it "must return true" do
+            expect(subject.validate(value)).to be(true)
+          end
+        end
+
+        context "but the value is not within the range of values" do
+          let(:value) { 0 }
+
+          it "must return [false, \"(...) not within the range of acceptable values (...)\"]" do
+            expect(subject.validate(value)).to eq(
+              [false, "(#{value.inspect}) not within the range of acceptable values (#{range.inspect})"]
+            )
+          end
+        end
+      end
     end
 
     context "when given a String" do
@@ -19,7 +61,31 @@ describe CommandMapper::Types::Num do
           expect(subject.validate(value)).to be(true)
         end
 
-        context "and the String contains a newline" do
+        context "when initialized with range: ..." do
+          let(:range) { 2..10 }
+
+          subject { described_class.new(range: range) }
+
+          context "and the value is within the range of values" do
+            let(:value) { '4' }
+
+            it "must return true" do
+              expect(subject.validate(value)).to be(true)
+            end
+          end
+
+          context "but the value is not within the range of values" do
+            let(:value) { '0' }
+
+            it "must return [false, \"(...) not within the range of acceptable values (...)\"]" do
+              expect(subject.validate(value)).to eq(
+                [false, "(#{value.inspect}) not within the range of acceptable values (#{range.inspect})"]
+              )
+            end
+          end
+        end
+
+        context "but the String contains a newline" do
           let(:value) { "01234\n56789" }
 
           it "must return [false, \"contains non-numeric characters (...)\"]" do
@@ -30,7 +96,7 @@ describe CommandMapper::Types::Num do
         end
       end
 
-      context "and it contains non-digits" do
+      context "but it contains non-digits" do
         let(:value) { "12abc34" }
 
         it "must return [false, \"contains non-numeric characters (...)\"]" do
@@ -42,7 +108,7 @@ describe CommandMapper::Types::Num do
     end
 
     context "when given another type of Object" do
-      context "but it defines a #to_i method" do
+      context "and it defines a #to_i method" do
         let(:value) { 1.0 }
 
         it "must return true" do
@@ -50,6 +116,30 @@ describe CommandMapper::Types::Num do
         end
       end
 
+      context "when initialized with range: ..." do
+        let(:range) { 2..10 }
+
+        subject { described_class.new(range: range) }
+
+        context "and the value is within the range of values" do
+          let(:value) { 4.0 }
+
+          it "must return true" do
+            expect(subject.validate(value)).to be(true)
+          end
+        end
+
+        context "but the value is not within the range of values" do
+          let(:value) { 0.0 }
+
+          it "must return [false, \"(...) not within the range of acceptable values (...)\"]" do
+            expect(subject.validate(value)).to eq(
+              [false, "(#{value.inspect}) not within the range of acceptable values (#{range.inspect})"]
+            )
+          end
+        end
+      end
+
       context "but it does not define a #to_i method" do
         let(:value) { Object.new }
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: command_mapper
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.1
 platform: ruby
 authors:
 - Postmodern
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-11-29 00:00:00.000000000 Z
+date: 2022-04-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -34,6 +34,7 @@ extra_rdoc_files:
 - LICENSE.txt
 - README.md
 files:
+- ".document"
 - ".github/workflows/ruby.yml"
 - ".gitignore"
 - ".rspec"
@@ -44,6 +45,7 @@ files:
 - README.md
 - Rakefile
 - commnad_mapper.gemspec
+- examples/grep.rb
 - gemspec.yml
 - lib/command_mapper.rb
 - lib/command_mapper/arg.rb