command_mapper 0.1.0.pre1

data/spec/option_value_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+require 'command_mapper/option_value'
+require 'command_mapper/types/list'
+
+describe CommandMapper::OptionValue do
+  describe "#format" do
+    let(:type) { Types::List.new }
+
+    subject { described_class.new(type: type) }
+
+    let(:value) { [1,2,3] }
+
+    it "must call the #type.format" do
+      expect(subject.format(value)).to eq(type.format(value))
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'rspec'
+require 'command_mapper/version'
+include CommandMapper
+
+require 'simplecov'
+SimpleCov.start

data/spec/sudo_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+require 'command_mapper/sudo'
+
+describe CommandMapper::Sudo do
+  let(:command) { %w[ls -la /root] }
+
+  subject { described_class.new({command: command}) }
+
+  describe "#initialize" do
+    it "must accept a command keyword" do
+      expect(subject.command).to eq(command)
+    end
+  end
+
+  describe "#argv" do
+    it "the first argument must be 'sudo'" do
+      expect(subject.command_argv.first).to eq('sudo')
+    end
+
+    it "must end with the command arguments" do
+      expect(subject.command_argv[-command.length..-1]).to eq(command)
+    end
+  end
+end

data/spec/types/enum_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+require 'command_mapper/types/enum'
+
+describe CommandMapper::Types::Enum do
+  let(:values) { [:foo, 42, :bar] }
+
+  subject { described_class.new(values) }
+
+  describe "#initialize" do
+    it "must set #values" do
+      expect(subject.values).to eq(values)
+    end
+
+    it "must populate #map with the values and their String forms" do
+      expect(subject.map).to eq(
+        Hash[values.map { |value|
+          [value, value.to_s]
+        }]
+      )
+    end
+  end
+
+  describe ".[]" do
+    subject { described_class[*values] }
+
+    it "must create a new Enum with the given values" do
+      expect(subject).to be_kind_of(described_class)
+      expect(subject.values).to eq(values)
+    end
+  end
+end

data/spec/types/hex_spec.rb

@@ -0,0 +1,158 @@
+require 'spec_helper'
+require 'command_mapper/types/hex'
+
+describe CommandMapper::Types::Hex do
+  describe "#initialize" do
+    it "must default #leading_zero? to false" do
+      expect(subject.leading_zero?).to be(false)
+    end
+
+    context "when initialized with leading_zero: true" do
+      subject { described_class.new(leading_zero: true) }
+
+      it "must set #leading_zero? to true" do
+        expect(subject.leading_zero?).to be(true)
+      end
+    end
+  end
+
+  describe "#leading_zero?" do
+    context "when initialized with leading_zero: true" do
+      subject { described_class.new(leading_zero: true) }
+
+      it "must return true" do
+        expect(subject.leading_zero?).to be(true)
+      end
+    end
+
+    context "when initialized with leading_zero: false" do
+      subject { described_class.new(leading_zero: false) }
+
+      it "must return false" do
+        expect(subject.leading_zero?).to be(false)
+      end
+    end
+  end
+
+  describe "#validate" do
+    context "when given a String" do
+      context "and the String only contains decimal digits" do
+        let(:value) { "0123456789" }
+
+        it "must return true" do
+          expect(subject.validate(value)).to be(true)
+        end
+
+        context "and the String begins with a '0x'" do
+          let(:value) { "0x0123456789" }
+
+          it "must return true" do
+            expect(subject.validate(value)).to be(true)
+          end
+        end
+
+        context "and the String contains a newline" do
+          let(:value) { "01234\n56789" }
+
+          it "must return [false, \"not in hex format (...)\"]" do
+            expect(subject.validate(value)).to eq(
+              [false, "not in hex format (#{value.inspect})"]
+            )
+          end
+        end
+      end
+
+      context "and the String only contains hex digits" do
+        let(:value) { "abcdef" }
+
+        it "must return true" do
+          expect(subject.validate(value)).to be(true)
+        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
+        end
+
+        context "and the String contains a newline" do
+          let(:value) { "abc\ndef" }
+
+          it "must return [false, \"not in hex format (...)\"]" do
+            expect(subject.validate(value)).to eq(
+              [false, "not in hex format (#{value.inspect})"]
+            )
+          end
+        end
+      end
+
+      context "but the String does not contain other characters" do
+        let(:value) { "foo" }
+
+        it "must return [false, \"not in hex format (...)\"]" do
+          expect(subject.validate(value)).to eq(
+            [false, "not in hex format (#{value.inspect})"]
+          )
+        end
+
+        context "and the String contains a newline" do
+          let(:value) { "foo\nbar" }
+
+          it "must return [false, \"not in hex format (...)\"]" do
+            expect(subject.validate(value)).to eq(
+              [false, "not in hex format (#{value.inspect})"]
+            )
+          end
+        end
+      end
+    end
+  end
+
+  describe "#format" do
+    context "when given an Integer" do
+      let(:value) { 255 }
+
+      it "must return the hexadecimal form of the Integer" do
+        expect(subject.format(value)).to eq("ff")
+      end
+
+      context "when initialized with leading_zero: true" do
+        subject { described_class.new(leading_zero: true) }
+
+        it "must prepend the hexadecimal number with '0x'" do
+          expect(subject.format(value)).to eq("0xff")
+        end
+      end
+    end
+
+    context "when given a String" do
+      context "and it contains hexadecimal digits" do
+        let(:value) { "ff" }
+
+        it "must return the String" do
+          expect(subject.format(value)).to eq("ff")
+        end
+
+        context "but the String does start with '0x'" do
+          let(:value) { "0xff" }
+
+          it "must remove '0x' prefix" do
+            expect(subject.format(value)).to eq("ff")
+          end
+        end
+
+        context "when #leading_zero? is true" do
+          subject { described_class.new(leading_zero: true) }
+
+          context "but the String does not start with '0x'" do
+            it "must prepend the String with '0x'" do
+              expect(subject.format(value)).to eq("0xff")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/types/input_dir_spec.rb

@@ -0,0 +1,30 @@
+require 'spec_helper'
+require 'command_mapper/types/input_dir'
+
+describe CommandMapper::Types::InputDir do
+  describe "#validate" do
+    context "when given a valid file path" do
+      let(:value) { __FILE__ }
+
+      it "must return [false, 'directory does not exist (...)']" do
+        expect(subject.validate(value)).to eq([false, "directory does not exist (#{value.inspect})"])
+      end
+    end
+
+    context "when given a valid directory path" do
+      let(:value) { __dir__ }
+
+      it "must return true" do
+        expect(subject.validate(value)).to eq(true)
+      end
+    end
+
+    context "when given a path that does not exist" do
+      let(:value) { "/path/does/not/exist" }
+
+      it "must return [false, 'path does not exist (...)']" do
+        expect(subject.validate(value)).to eq([false, "path does not exist (#{value.inspect})"])
+      end
+    end
+  end
+end

data/spec/types/input_file_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'command_mapper/types/input_file'
+
+describe CommandMapper::Types::InputFile do
+  describe "#validate" do
+    context "when given a valid file path" do
+      let(:value) { __FILE__ }
+
+      it "must return true" do
+        expect(subject.validate(value)).to be(true)
+      end
+    end
+
+    context "when given a valid directory path" do
+      let(:value) { __dir__ }
+
+      it "must return [false, 'file does not exist (...)']" do
+        expect(subject.validate(value)).to eq(
+          [false, "file does not exist (#{value.inspect})"]
+        )
+      end
+    end
+
+    context "when given a path that does not exist" do
+      let(:value) { "/path/does/not/exist" }
+
+      it "must return [false, 'path does not exist (...)']" do
+        expect(subject.validate(value)).to eq(
+          [false, "path does not exist (#{value.inspect})"]
+        )
+      end
+    end
+  end
+end

data/spec/types/input_path_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'command_mapper/types/input_path'
+
+describe CommandMapper::Types::InputPath do
+  describe "#validate" do
+    context "when given a valid file path" do
+      let(:value) { __FILE__ }
+
+      it "must return true" do
+        expect(subject.validate(value)).to be(true)
+      end
+    end
+
+    context "when given a valid directory path" do
+      let(:value) { __dir__ }
+
+      it "must return true" do
+        expect(subject.validate(value)).to be(true)
+      end
+    end
+
+    context "when given a path that does not exist" do
+      let(:value) { "/path/does/not/exist" }
+
+      it "must return [false, 'path does not exist (...)']" do
+        expect(subject.validate(value)).to eq(
+          [false, "path does not exist (#{value.inspect})"]
+        )
+      end
+    end
+  end
+end

data/spec/types/key_value_list_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+require 'command_mapper/types/key_value_list'
+
+describe CommandMapper::Types::KeyValueList do
+  describe "#initialize" do
+    it "must default #separator to ','" do
+      expect(subject.separator).to eq(',')
+    end
+
+    it "must initialize #type to a Types::KeyValue object" do
+      expect(subject.type).to be_kind_of(Types::KeyValue)
+    end
+
+    it "must default #type.separator to '='" do
+      expect(subject.type.separator).to eq('=')
+    end
+
+    context "when given the separator: keyword" do
+      let(:separator) { ';' }
+
+      subject { described_class.new(separator: separator) }
+
+      it "must set #separator" do
+        expect(subject.separator).to eq(separator)
+      end
+    end
+
+    context "when given the key_value_separator: keyword" do
+      let(:separator) { ':' }
+
+      subject { described_class.new(key_value_separator: separator) }
+
+      it "must set #type.separator" do
+        expect(subject.type.separator).to eq(separator)
+      end
+    end
+  end
+
+  describe "#format" do
+    context "when given an Array" do
+      context "containing a single key:value pair" do
+        let(:key)   { "foo" }
+        let(:value) { 42    }
+
+        let(:array) { [[key, value]] }
+
+        it "must join the key and value with #type.separator" do
+          expect(subject.format(array)).to eq(
+            "#{key}#{subject.type.separator}#{value}"
+          )
+        end
+      end
+
+      context "when given multiple key:value pairs" do
+        let(:key1)   { "foo" }
+        let(:value1) { 42    }
+        let(:key2)   { "bar" }
+        let(:value2) { 100   }
+
+        let(:array) { [[key1, value1], [key2, value2]] }
+
+        it "must join the keys and values with #type.separator, and then with #separator" do
+          expect(subject.format(array)).to eq(
+            "#{key1}#{subject.type.separator}#{value1}#{subject.separator}#{key2}#{subject.type.separator}#{value2}"
+          )
+        end
+      end
+    end
+
+    context "when given an Hash" do
+      context "containing a single key:value pair" do
+        let(:key)   { "foo" }
+        let(:value) { 42    }
+
+        let(:hash) { {key => value} }
+
+        it "must join the key and value with #type.separator" do
+          expect(subject.format(hash)).to eq(
+            "#{key}#{subject.type.separator}#{value}"
+          )
+        end
+      end
+
+      context "containing multiple key:value pairs" do
+        let(:key1)   { "foo" }
+        let(:value1) { 42    }
+        let(:key2)   { "bar" }
+        let(:value2) { 100   }
+
+        let(:hash) { {key1 => value1, key2 => value2} }
+
+        it "must join the keys and values with #type.separator, and then with #separator" do
+          expect(subject.format(hash)).to eq(
+            "#{key1}#{subject.type.separator}#{value1}#{subject.separator}#{key2}#{subject.type.separator}#{value2}"
+          )
+        end
+      end
+    end
+  end
+end