command_mapper 0.1.0.pre1

data/spec/types/key_value_spec.rb

@@ -0,0 +1,272 @@
+require 'spec_helper'
+require 'command_mapper/types/key_value'
+require 'command_mapper/types/num'
+require 'command_mapper/types/list'
+
+describe CommandMapper::Types::KeyValue do
+  describe "#initialize" do
+    it "must default #separator to '='" do
+      expect(subject.separator).to eq('=')
+    end
+
+    it "must initialize #key" do
+      expect(subject.key).to be_kind_of(CommandMapper::Types::Str)
+    end
+
+    it "must require a non-empty 'key' value by default" do
+      expect(subject.key.allow_empty?).to be(false)
+    end
+
+    it "must initialize #value" do
+      expect(subject.value).to be_kind_of(CommandMapper::Types::Str)
+    end
+
+    it "must require a non-empty 'value' value by default" do
+      expect(subject.value.allow_empty?).to be(false)
+    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 key: nil" do
+      it do
+        expect {
+          described_class.new(key: nil)
+        }.to raise_error(ArgumentError,"key: keyword cannot be nil")
+      end
+    end
+
+    context "when given value: nil" do
+      it do
+        expect {
+          described_class.new(value: nil)
+        }.to raise_error(ArgumentError,"value: keyword cannot be nil")
+      end
+    end
+  end
+
+  describe "#validate" do
+    context "when given a Hash" do
+      context "but it's empty" do
+        let(:hash) { {} }
+
+        it "must return [false, \"cannot be empty\"]" do
+          expect(subject.validate(hash)).to eq(
+            [false, "cannot be empty"]
+          )
+        end
+      end
+
+      context "and the Hash contains only one key:value pair" do
+        let(:key)   { "foo" }
+        let(:value) { "bar" }
+        let(:hash)  { {key => value} }
+
+        it "must return true" do
+          expect(subject.validate(hash)).to be(true)
+        end
+
+        context "when #key is a custom Types::Type object" do
+          let(:key_type) { Types::Num.new }
+          let(:key) { "foo" }
+
+          subject { described_class.new(key: key_type) }
+
+          it "must validate the key value using #key.validate" do
+            expect(subject.validate(hash)).to eq(
+              [false, "key contains non-numeric characters (#{key.inspect})"]
+            )
+          end
+        end
+
+        context "when #value is a custom Types::Type object" do
+          let(:value_type) { Types::Num.new }
+          let(:value)      { "foo"          }
+
+          subject { described_class.new(value: value_type) }
+
+          it "must validate the key value using #key.validate" do
+            expect(subject.validate(hash)).to eq(
+              [false, "value contains non-numeric characters (#{value.inspect})"]
+            )
+          end
+        end
+      end
+
+      context "but the Hash contains more than one pair" do
+        let(:hash)  { {"foo" => "bar", "baz" => "qux"} }
+
+        it "must return [false, \"cannot contain multiple key:value pairs (...)\"]" do
+          expect(subject.validate(hash)).to eq(
+            [false, "cannot contain multiple key:value pairs (#{hash.inspect})"]
+          )
+        end
+      end
+    end
+
+    context "when given an Array" do
+      context "but the Array is empty" do
+        let(:array) { [] }
+
+        it "must return [false, \"must contain two elements (...)\"]" do
+          expect(subject.validate(array)).to eq(
+            [false, "must contain two elements (#{array.inspect})"]
+          )
+        end
+      end
+
+      context "and the Array contains only one elemnet" do
+        let(:array) { ["foo"] }
+
+        it "must return true" do
+          expect(subject.validate(array)).to eq(
+            [false, "must contain two elements (#{array.inspect})"]
+          )
+        end
+      end
+
+      context "and the Array contains only two elements" do
+        let(:key)   { "foo" }
+        let(:value) { "bar" }
+        let(:array) { [key, value] }
+
+        it "must return true" do
+          expect(subject.validate(array)).to be(true)
+        end
+
+        context "when #key is a custom Types::Type object" do
+          let(:key_type) { Types::Num.new }
+          let(:key) { "foo" }
+
+          subject { described_class.new(key: key_type) }
+
+          it "must validate the key value using #key.validate" do
+            expect(subject.validate(array)).to eq(
+              [false, "key contains non-numeric characters (#{key.inspect})"]
+            )
+          end
+        end
+
+        context "when #value is a custom Types::Type object" do
+          let(:value_type) { Types::Num.new }
+          let(:value)      { "foo"          }
+
+          subject { described_class.new(value: value_type) }
+
+          it "must validate the key value using #key.validate" do
+            expect(subject.validate(array)).to eq(
+              [false, "value contains non-numeric characters (#{value.inspect})"]
+            )
+          end
+        end
+      end
+
+      context "but the Array contains more than two elements" do
+        let(:array) { ["foo", "bar", "baz"] }
+
+        it "must return [false, \"cannot contain more than two elements (...)\"]" do
+          expect(subject.validate(array)).to eq(
+            [false, "cannot contain more than two elements (#{array.inspect})"]
+          )
+        end
+      end
+    end
+  end
+
+  describe "#format" do
+    context "when given a Hash" do
+      let(:key)   { "foo" }
+      let(:value) { "bar" }
+      let(:hash)  { {key => value} }
+
+      it "must format the hash'es key and value into a key=value pair" do
+        expect(subject.format(hash)).to eq("#{key}=#{value}")
+      end
+
+      context "when initialized with a custom key: keyword argument" do
+        subject { described_class.new(key: Types::Num.new) }
+
+        let(:key) { 42 }
+
+        it "must format the key using #key.format" do
+          expect(subject.format(hash)).to eq("#{key}=#{value}")
+        end
+      end
+
+      context "when initialized with a custom key: keyword argument" do
+        subject { described_class.new(value: Types::List.new) }
+
+        let(:value) { %w[bar baz] }
+
+        it "must format the value using #value.format" do
+          expect(subject.format(hash)).to eq("#{key}=#{value.join(',')}")
+        end
+      end
+
+      context "when initialized with a custom separator" do
+        let(:separator) { ':' }
+
+        subject { described_class.new(separator: separator) }
+
+        it "must use the custom separator" do
+          expect(subject.format(hash)).to eq("#{key}#{separator}#{value}")
+        end
+      end
+    end
+
+    context "when given an Array" do
+      let(:key)   { "foo" }
+      let(:value) { "bar" }
+      let(:array) { [key, value] }
+
+      it "must format the array's first and second elements into a key=value pair" do
+        expect(subject.format(array)).to eq("#{key}=#{value}")
+      end
+
+      context "when initialized with a custom key: keyword argument" do
+        subject { described_class.new(key: Types::Num.new) }
+
+        let(:key) { 42 }
+
+        it "must format the key using #key.format" do
+          expect(subject.format(array)).to eq("#{key}=#{value}")
+        end
+      end
+
+      context "when initialized with a custom key: keyword argument" do
+        subject { described_class.new(value: Types::List.new) }
+
+        let(:value) { %w[bar baz] }
+
+        it "must format the value using #value.format" do
+          expect(subject.format(array)).to eq("#{key}=#{value.join(',')}")
+        end
+      end
+
+      context "when initialized with a custom separator" do
+        let(:separator) { ':' }
+
+        subject { described_class.new(separator: separator) }
+
+        it "must use the custom separator" do
+          expect(subject.format(array)).to eq("#{key}#{separator}#{value}")
+        end
+      end
+    end
+
+    context "when another kind of Object is given" do
+      let(:value) { 42 }
+
+      it "must return the String version of that object" do
+        expect(subject.format(value)).to eq(value.to_s)
+      end
+    end
+  end
+end

data/spec/types/list_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+require 'command_mapper/types/list'
+require 'command_mapper/types/num'
+
+describe CommandMapper::Types::List do
+  describe "#initialize" do
+    it "must default #separator to ','" do
+      expect(subject.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 type: keyword argument" do
+      context "and it's a Types::Type object" do
+        let(:type) { Types::Num.new }
+
+        subject { described_class.new(type: type) }
+
+        it "must set a custom #type" do
+          expect(subject.type).to eq(type)
+        end
+      end
+
+      context "but it's nil" do
+        it do
+          expect {
+            described_class.new(type: nil)
+          }.to raise_error(ArgumentError,"type: keyword cannot be nil")
+        end
+      end
+    end
+  end
+
+  describe "#validate" do
+    context "when given a single value" do
+      let(:value) { "foo" }
+
+      it "must return true" do
+        expect(subject.validate(value)).to be(true)
+      end
+
+      context "but the value is nil" do
+        let(:value) { nil }
+
+        it "must return [false, \"cannot be empty\"]" do
+          expect(subject.validate(value)).to eq(
+            [false, "cannot be empty"]
+          )
+        end
+
+        context "when #allow_empty? is true" do
+          subject { described_class.new(allow_empty: true) }
+
+          it "must return true" do
+            expect(subject.validate(value)).to be(true)
+          end
+        end
+      end
+
+      context "and the value is invalid" do
+        let(:value) { "" }
+
+        it "must return the validation error from #type.validate" do
+          expect(subject.validate(value)).to eq(
+            [false, "element does not allow an empty value"]
+          )
+        end
+      end
+    end
+
+    context "when given multiple values" do
+      let(:values) { %w[foo bar baz] }
+
+      it "must return true" do
+        expect(subject.validate(values)).to be(true)
+      end
+
+      context "but the value is []" do
+        let(:value) { [] }
+
+        it "must return [false, \"cannot be empty\"]" do
+          expect(subject.validate(value)).to eq(
+            [false, "cannot be empty"]
+          )
+        end
+
+        context "when #allow_empty? is true" do
+          subject { described_class.new(allow_empty: true) }
+
+          it "must return true" do
+            expect(subject.validate(value)).to be(true)
+          end
+        end
+      end
+
+      context "but one of the values is invalid" do
+        let(:values) { ["foo", nil, "bar"] }
+
+        it "must return the validation error from #type.validate" do
+          expect(subject.validate(values)).to eq(
+            [false, "element cannot be nil"]
+          )
+        end
+      end
+    end
+  end
+
+  describe "#format" do
+    context "when given a single value" do
+      let(:value) { "foo" }
+
+      it "must return the String version of that value" do
+        expect(subject.format(value)).to eq(value.to_s)
+      end
+    end
+
+    context "when given multiple values" do
+      let(:values) { %w[foo bar baz] }
+
+      it "must join the values with ','" do
+        expect(subject.format(values)).to eq(values.join(','))
+      end
+
+      context "when initialized with a custom separator" do
+        let(:separator) { ':' }
+
+        subject { described_class.new(separator: separator) }
+
+        it "must join the values with #separator" do
+          expect(subject.format(values)).to eq(values.join(subject.separator))
+        end
+      end
+    end
+  end
+end

data/spec/types/map_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+require 'command_mapper/types/map'
+
+describe CommandMapper::Types::Map do
+  let(:map) { {1 => 'one', 2 => 'two'} }
+
+  subject { described_class.new(map) }
+
+  describe "#initialize" do
+    it "must initialize #map" do
+      expect(subject.map).to eq(map)
+    end
+  end
+
+  describe ".[]" do
+    subject { described_class[map] }
+
+    it "must create a new Map with the given values" do
+      expect(subject).to be_kind_of(described_class)
+      expect(subject.map).to eq(map)
+    end
+  end
+
+  describe "#validate" do
+    context "when given a value that's in the map" do
+      let(:value) { 2 }
+
+      it "must return true" do
+        expect(subject.validate(value)).to be(true)
+      end
+    end
+    context "when given a value that is not in the map" do
+      let(:value) { 42 }
+
+      it "must return [false, \"unknown value (...)\"]" do
+        expect(subject.validate(value)).to eq(
+          [false, "unknown value (#{value.inspect})"]
+        )
+      end
+    end
+  end
+
+  describe "#format" do
+    context "when given a value that's in the map" do
+      let(:value) { 2 }
+
+      it "must return the corresponding mapped value" do
+        expect(subject.format(value)).to eq(map[value])
+      end
+    end
+
+    context "when given a value that is not in the map" do
+      let(:value) { 42 }
+
+      it "must return the String version of the value" do
+        expect {
+          subject.format(value)
+        }.to raise_error(KeyError)
+      end
+    end
+  end
+end

data/spec/types/num_spec.rb

@@ -0,0 +1,90 @@
+require 'spec_helper'
+require 'command_mapper/types/num'
+
+describe CommandMapper::Types::Num do
+  describe "#validate" do
+    context "when given an Integer" do
+      let(:value) { 1 }
+
+      it "must return true" do
+        expect(subject.validate(value)).to be(true)
+      end
+    end
+
+    context "when given a String" do
+      context "and it contains only digits" do
+        let(:value) { "0123456789" }
+
+        it "must return true" do
+          expect(subject.validate(value)).to be(true)
+        end
+
+        context "and the String contains a newline" do
+          let(:value) { "01234\n56789" }
+
+          it "must return [false, \"contains non-numeric characters (...)\"]" do
+            expect(subject.validate(value)).to eq(
+              [false, "contains non-numeric characters (#{value.inspect})"]
+            )
+          end
+        end
+      end
+
+      context "and it contains non-digits" do
+        let(:value) { "12abc34" }
+
+        it "must return [false, \"contains non-numeric characters (...)\"]" do
+          expect(subject.validate(value)).to eq(
+            [false, "contains non-numeric characters (#{value.inspect})"]
+          )
+        end
+      end
+    end
+
+    context "when given another type of Object" do
+      context "but it defines a #to_i method" do
+        let(:value) { 1.0 }
+
+        it "must return true" do
+          expect(subject.validate(value)).to be(true)
+        end
+      end
+
+      context "but it does not define a #to_i method" do
+        let(:value) { Object.new }
+
+        it "must return [false, \"value cannot be converted into an Integer\"]" do
+          expect(subject.validate(value)).to eq(
+            [false, "cannot be converted into an Integer (#{value.inspect})"]
+          )
+        end
+      end
+    end
+  end
+
+  describe "#format" do
+    context "when given a String" do
+      let(:value) { "1234567890" }
+
+      it "must return the same String" do
+        expect(subject.format(value)).to eq(value)
+      end
+    end
+
+    context "when given an Intger" do
+      let(:value) { 1234567890 }
+
+      it "must convert the Integer into a String" do
+        expect(subject.format(value)).to eq(value.to_s)
+      end
+    end
+
+    context "when given another type of Object" do
+      let(:value) { 1.0 }
+
+      it "must call #to_i then #to_s" do
+        expect(subject.format(value)).to eq(value.to_i.to_s)
+      end
+    end
+  end
+end