rake-funnel 0.0.1.pre

data/spec/rake/funnel/support/mapper_spec.rb

@@ -0,0 +1,87 @@
+describe Rake::Funnel::Support::Mapper do
+  describe 'Manual debugging test case' do
+    it 'should work' do
+      args = {
+        unset: nil,
+        simple: 1,
+        array: [1, 2, nil],
+        hash: { one: 1, two: 2, unset: nil },
+        enum_hash: [{ one: 1 }, { two: 2 }, { unset: nil }]
+      }
+
+      _ = subject.map(args)
+      expect(_).not_to be_empty
+
+      skip('for manual testing only')
+    end
+  end
+
+  class CustomMapper
+    def generate_from(_)
+      [
+        ['-', 'switch'],
+        ['-', :some_switch],
+        ['-', :another_switch, '=', :some_value],
+        ['-string switch', '=', 'string value']
+      ]
+    end
+  end
+
+  describe 'mapping' do
+    it 'should support nil args' do
+      expect(subject.map(nil)).to be_empty
+    end
+
+    it 'should support empty args' do
+      expect(subject.map({})).to be_empty
+    end
+  end
+
+  describe 'mapper style' do
+    context 'default mapper' do
+      it 'should use default mapper' do
+        expect(described_class.new).to be
+      end
+    end
+
+    context 'unknown mapper' do
+      it 'should fail' do
+        expect { described_class.new(:unknown) }.to raise_error(/^Something went wrong while creating the 'unknown' mapper/)
+      end
+    end
+
+    context 'nil mapper' do
+      it 'should fail' do
+        expect { described_class.new(nil) }.to raise_error(/You cannot use a 'nil' mapper. Available mappers are: \w+/)
+      end
+    end
+
+    context 'custom mapper' do
+      it 'should take custom mapper instance' do
+        expect(described_class.new(CustomMapper.new)).to be
+      end
+    end
+  end
+
+  describe 'mapper output' do
+    subject { described_class.new(CustomMapper.new) }
+
+    it 'should join nested arrays' do
+      expect(subject.map).to include('-switch')
+    end
+
+    describe 'snake case to camel case conversion' do
+      it 'should convert symbols keys' do
+        expect(subject.map).to include('-someSwitch')
+      end
+
+      it 'should convert symbol values' do
+        expect(subject.map).to include('-anotherSwitch=someValue')
+      end
+
+      it 'should not convert strings' do
+        expect(subject.map).to include('-string switch=string value')
+      end
+    end
+  end
+end

data/spec/rake/funnel/support/mapper_styles/msdeploy_spec.rb

@@ -0,0 +1,222 @@
+include Rake::Funnel::Support
+
+describe Rake::Funnel::Support::MapperStyles::MSDeploy do
+  subject { Mapper.new(:MSDeploy) }
+
+  describe 'no arguments' do
+    it 'should convert no args to []' do
+      expect(subject.map).to match_array([])
+    end
+
+    it 'should convert {} to []' do
+      expect(subject.map({})).to match_array([])
+    end
+  end
+
+  describe 'truthy arguments' do
+    it 'should convert switch => <true>' do
+      args = { switch: true }
+      expect(subject.map(args)).to match_array(['-switch:true'])
+    end
+
+    it 'should convert switch => <truthy>' do
+      args = { switch: 1 }
+      expect(subject.map(args)).to match_array(['-switch:1'])
+    end
+
+    it 'should convert switch => <symbol>' do
+      args = { switch: :one }
+      expect(subject.map(args)).to match_array(['-switch:one'])
+    end
+
+    it 'should convert switch => <string>' do
+      args = { switch: 'one' }
+      expect(subject.map(args)).to match_array(['-switch:one'])
+    end
+
+    it 'should convert switch => <truthy> enumerable' do
+      args = { switch: [true, 1] }
+      expect(subject.map(args)).to match_array(%w(-switch:true -switch:1))
+    end
+
+    it 'should convert hash values' do
+      args = { switch: { foo: true, bar: true } }
+      expect(subject.map(args)).to match_array(['-switch:foo=true,bar=true'])
+    end
+
+    it 'should convert enumerable hash values' do
+      args = { switch: [{ foo: true, bar: 1 }, { baz: :baz, foobar: 'foobar' }] }
+      expect(subject.map(args)).to match_array(%w(-switch:foo=true,bar=1 -switch:baz=baz,foobar=foobar))
+    end
+  end
+
+  describe 'falsy arguments' do
+    it 'should convert switch => <false>' do
+      args = { switch: false }
+      expect(subject.map(args)).to match_array(['-switch:false'])
+    end
+
+    it 'should convert switch => <falsy>' do
+      args = { switch: nil }
+      expect(subject.map(args)).to match_array(['-switch'])
+    end
+
+    it 'should convert switch => <falsy> enumerable' do
+      args = { switch: [false, nil] }
+      expect(subject.map(args)).to match_array(%w(-switch:false -switch))
+    end
+
+    it 'should convert hash values' do
+      args = { switch: { foo: false, bar: nil } }
+      expect(subject.map(args)).to match_array(['-switch:foo=false,bar'])
+    end
+
+    it 'should convert enumerable hash values' do
+      args = { switch: [{ foo: false }, { bar: nil }] }
+      expect(subject.map(args)).to match_array(%w(-switch:foo=false -switch:bar))
+    end
+  end
+
+  describe 'complex types' do
+    it 'should convert switch => <enumerable>' do
+      args = { switch: [1, 'two'] }
+      expect(subject.map(args)).to match_array(%w(-switch:1 -switch:two))
+    end
+
+    it 'should convert switch => <hash>' do
+      args = { switch: { one: 1, two: 2 } }
+      expect(subject.map(args)).to match_array(['-switch:one=1,two=2'])
+    end
+
+    it 'should convert switch => <enumerable of hash>' do
+      args = { switch: [{ one: 1 }, { two: 2 }] }
+      expect(subject.map(args)).to match_array(%w(-switch:one=1 -switch:two=2))
+    end
+  end
+
+  describe 'snake case to camel case conversion' do
+    it 'should convert symbols keys' do
+      args = { some_switch: 1 }
+      expect(subject.map(args)).to match_array(['-someSwitch:1'])
+    end
+
+    it 'should convert symbol values' do
+      args = { switch: :some_value }
+      expect(subject.map(args)).to match_array(['-switch:someValue'])
+    end
+
+    it 'should convert enumerable values' do
+      args = { switch: [:some_value] }
+      expect(subject.map(args)).to match_array(['-switch:someValue'])
+    end
+
+    it 'should convert hash values' do
+      args = { switch: { key: :some_value } }
+      expect(subject.map(args)).to match_array(['-switch:key=someValue'])
+    end
+
+    it 'should convert hash keys' do
+      args = { switch: { some_key: true } }
+      expect(subject.map(args)).to match_array(['-switch:someKey=true'])
+    end
+
+    it 'should convert enumerable hash values' do
+      args = { switch: [{ key: :some_value }] }
+      expect(subject.map(args)).to match_array(['-switch:key=someValue'])
+    end
+
+    it 'should convert enumerable hash keys' do
+      args = { switch: [{ some_key: true }] }
+      expect(subject.map(args)).to match_array(['-switch:someKey=true'])
+    end
+
+    it 'should not convert strings' do
+      args = { 'some_switch' => 'some_value' }
+      expect(subject.map(args)).to match_array(['-some_switch:some_value'])
+    end
+  end
+
+  describe 'whitespace' do
+    describe 'keys' do
+      context 'without quotes' do
+        it 'should enclose keys in "' do
+          args = { 'some key' => 1 }
+          expect(subject.map(args)).to match_array(['-"some key":1'])
+        end
+
+        it 'should enclose hash keys in "' do
+          args = { switch: { 'some key' => 1 } }
+          expect(subject.map(args)).to match_array(['-switch:"some key"=1'])
+        end
+
+        it 'should enclose enumerable hash keys in "' do
+          args = { switch: [{ 'some key' => 1 }] }
+          expect(subject.map(args)).to match_array(['-switch:"some key"=1'])
+        end
+      end
+
+      context 'with quotes' do
+        it 'should escape quotes' do
+          args = { 'some "key"' => 1 }
+          expect(subject.map(args)).to match_array(['-"some ""key""":1'])
+        end
+
+        it 'should escape quotes in hash keys' do
+          args = { switch: { 'some "key"' => 1 } }
+          expect(subject.map(args)).to match_array(['-switch:"some ""key"""=1'])
+        end
+
+        it 'should escape quotes in enumerable hash keys' do
+          args = { switch: [{ 'some "key"' => 1 }] }
+          expect(subject.map(args)).to match_array(['-switch:"some ""key"""=1'])
+        end
+      end
+    end
+
+    describe 'values' do
+      context 'without quotes' do
+        it 'should enclose values in "' do
+          args = { switch: 'some value' }
+          expect(subject.map(args)).to match_array(['-switch:"some value"'])
+        end
+
+        it 'should enclose enumerable values in "' do
+          args = { switch: ['some value'] }
+          expect(subject.map(args)).to match_array(['-switch:"some value"'])
+        end
+
+        it 'should enclose hash values in "' do
+          args = { switch: { key: 'some value' } }
+          expect(subject.map(args)).to match_array(['-switch:key="some value"'])
+        end
+
+        it 'should enclose enumerable hash values in "' do
+          args = { switch: [{ key: 'some value' }] }
+          expect(subject.map(args)).to match_array(['-switch:key="some value"'])
+        end
+      end
+
+      context 'with quotes' do
+        it 'should escape quotes' do
+          args = { switch: 'some "value"' }
+          expect(subject.map(args)).to match_array(['-switch:"some ""value"""'])
+        end
+
+        it 'should escape quotes in enumerable values' do
+          args = { switch: ['some "value"'] }
+          expect(subject.map(args)).to match_array(['-switch:"some ""value"""'])
+        end
+
+        it 'should escape quotes in hash values' do
+          args = { switch: { key: 'some "value"' } }
+          expect(subject.map(args)).to match_array(['-switch:key="some ""value"""'])
+        end
+
+        it 'should escape quotes in enumerable hash values' do
+          args = { switch: [{ key: 'some "value"' }] }
+          expect(subject.map(args)).to match_array(['-switch:key="some ""value"""'])
+        end
+      end
+    end
+  end
+end

data/spec/rake/funnel/support/mapper_styles/nunit_spec.rb

@@ -0,0 +1,25 @@
+describe Rake::Funnel::Support::MapperStyles::NUnit do
+  subject { Mapper.new(:NUnit) }
+
+  describe 'prefix' do
+    before {
+      allow(Rake::Win32).to receive(:windows?).and_return(windows?)
+    }
+
+    context 'on Windows' do
+      let(:windows?) { true }
+
+      it "should use '/'" do
+        expect(subject.map({ switch: nil })).to eq(['/switch'])
+      end
+    end
+
+    context 'not on Windows' do
+      let(:windows?) { false }
+
+      it "should use '-'" do
+        expect(subject.map({ switch: nil })).to eq(['-switch'])
+      end
+    end
+  end
+end

data/spec/rake/funnel/support/mapper_styles/styles_spec.rb

@@ -0,0 +1,214 @@
+include Rake::Funnel::Support
+
+MapperStyles.constants.reject { |x| x == :MSDeploy }.each do |style|
+  style_path = MapperStyles.const_get(style)
+  describe style_path do
+    subject {
+      Mapper.new(style)
+    }
+
+    let (:style) {
+      MapperStyles.const_get(style).new
+    }
+
+    def styled(switch, key = nil, value = nil)
+      unless style.respond_to?(:separator)
+        styled = [
+          [
+            style.prefix,
+            switch
+          ],
+          [
+            key && key,
+            value && style.value_separator,
+            value && value
+          ]
+        ]
+      else
+        styled = [
+          [
+            style.prefix,
+            switch,
+            key && style.separator,
+            key && key,
+            value && style.value_separator,
+            value && value
+          ]
+        ]
+      end
+
+      styled.map(&:join).reject(&:empty?)
+    end
+
+    describe 'no arguments' do
+      it 'should convert no args to []' do
+        expect(subject.map).to match_array([])
+      end
+
+      it 'should convert {} to []' do
+        expect(subject.map({})).to match_array([])
+      end
+    end
+
+    describe 'truthy arguments' do
+      it 'should convert switch => <true>' do
+        args = { switch: true }
+        expect(subject.map(args)).to match_array(styled('switch', 'true'))
+      end
+
+      it 'should convert switch => <truthy>' do
+        args = { switch: 1 }
+        expect(subject.map(args)).to match_array(styled('switch', '1'))
+      end
+
+      it 'should convert switch => <symbol>' do
+        args = { switch: :one }
+        expect(subject.map(args)).to match_array(styled('switch', 'one'))
+      end
+
+      it 'should convert switch => <string>' do
+        args = { switch: 'one' }
+        expect(subject.map(args)).to match_array(styled('switch', 'one'))
+      end
+
+      it 'should convert switch => <truthy> enumerable' do
+        args = { switch: [true, 1] }
+        expect(subject.map(args)).to match_array(
+            [
+              *styled('switch', 'true'),
+              *styled('switch', '1')
+            ])
+      end
+
+      it 'should convert hash values' do
+        args = { switch: { foo: true, bar: true } }
+        expect(subject.map(args)).to match_array(
+            [
+              *styled('switch', 'foo', 'true'),
+              *styled('switch', 'bar', 'true')
+            ])
+      end
+
+      it 'should convert enumerable hash values' do
+        args = { switch: [{ foo: true, bar: 1 }, { baz: :baz, foobar: 'foobar' }] }
+        expect(subject.map(args)).to match_array(
+            [
+              *styled('switch', 'foo', 'true'),
+              *styled('switch', 'bar', '1'),
+              *styled('switch', 'baz', 'baz'),
+              *styled('switch', 'foobar', 'foobar'),
+            ])
+      end
+    end
+
+    describe 'falsy arguments' do
+      it 'should convert switch => <false>' do
+        args = { switch: false }
+        expect(subject.map(args)).to match_array(styled('switch', 'false'))
+      end
+
+      it 'should convert switch => <falsy>' do
+        args = { switch: nil }
+        expect(subject.map(args)).to match_array(styled('switch'))
+      end
+
+      it 'should convert switch => <falsy> enumerable' do
+        args = { switch: [false, nil] }
+        expect(subject.map(args)).to match_array(
+            [
+              *styled('switch', 'false'),
+              *styled('switch')
+            ])
+      end
+
+      it 'should convert hash values' do
+        args = { switch: { foo: false, bar: nil } }
+        expect(subject.map(args)).to match_array(
+            [
+              *styled('switch', 'foo', 'false'),
+              *styled('switch', 'bar')
+            ])
+      end
+
+      it 'should convert enumerable hash values' do
+        args = { switch: [{ foo: false }, { bar: nil }] }
+        expect(subject.map(args)).to match_array(
+            [
+              *styled('switch', 'foo', 'false'),
+              *styled('switch', 'bar')
+            ])
+      end
+    end
+
+    describe 'complex types' do
+      it 'should convert switch => <enumerable>' do
+        args = { switch: [1, 'two'] }
+        expect(subject.map(args)).to match_array(
+            [
+              *styled('switch', '1'),
+              *styled('switch', 'two')
+            ])
+      end
+
+      it 'should convert switch => <hash>' do
+        args = { switch: { one: 1, two: 2 } }
+        expect(subject.map(args)).to match_array(
+            [
+              *styled('switch', 'one', '1'),
+              *styled('switch', 'two', '2')
+            ])
+      end
+
+      it 'should convert switch => <enumerable of hash>' do
+        args = { switch: [{ one: 1 }, { two: 2 }] }
+        expect(subject.map(args)).to match_array(
+            [
+              *styled('switch', 'one', '1'),
+              *styled('switch', 'two', '2')
+            ])
+      end
+    end
+
+    describe 'snake case to camel case conversion' do
+      it 'should convert symbols keys' do
+        args = { some_switch: 1 }
+        expect(subject.map(args)).to match_array(styled('someSwitch', '1'))
+      end
+
+      it 'should convert symbol values' do
+        args = { switch: :some_value }
+        expect(subject.map(args)).to match_array(styled('switch', 'someValue'))
+      end
+
+      it 'should convert enumerable values' do
+        args = { switch: [:some_value] }
+        expect(subject.map(args)).to match_array(styled('switch', 'someValue'))
+      end
+
+      it 'should convert hash values' do
+        args = { switch: { key: :some_value } }
+        expect(subject.map(args)).to match_array(styled('switch', 'key', 'someValue'))
+      end
+
+      it 'should convert hash keys' do
+        args = { switch: { some_key: true } }
+        expect(subject.map(args)).to match_array(styled('switch', 'someKey', 'true'))
+      end
+
+      it 'should convert enumerable hash values' do
+        args = { switch: [{ key: :some_value }] }
+        expect(subject.map(args)).to match_array(styled('switch', 'key', 'someValue'))
+      end
+
+      it 'should convert enumerable hash keys' do
+        args = { switch: [{ some_key: true }] }
+        expect(subject.map(args)).to match_array(styled('switch', 'someKey', 'true'))
+      end
+
+      it 'should not convert strings' do
+        args = { 'some_switch' => 'some_value' }
+        expect(subject.map(args)).to match_array(styled('some_switch', 'some_value'))
+      end
+    end
+  end
+end

data/spec/rake/funnel/support/mono_spec.rb

@@ -0,0 +1,57 @@
+require 'tmpdir'
+
+include Rake::Funnel::Support
+
+describe Rake::Funnel::Support::Mono do
+  before {
+    allow(Rake::Win32).to receive(:windows?).and_return(windows?)
+  }
+
+  context 'on Windows' do
+    let(:windows?) { true }
+
+    it 'should return executable' do
+      expect(described_class.invocation('executable.exe')).to eq(%w(executable.exe))
+    end
+
+    it 'should return executable with args' do
+      expect(described_class.invocation('executable.exe', 'arg1', 'arg2')).to eq(%w(executable.exe arg1 arg2))
+    end
+
+    it 'should return array executable with args' do
+      expect(described_class.invocation(%w(executable.exe arg1 arg2))).to eq(%w(executable.exe arg1 arg2))
+    end
+
+    it 'should reject nil in array' do
+      expect(described_class.invocation(%w(executable.exe arg1) << nil)).to eq(%w(executable.exe arg1))
+    end
+
+    it 'should reject nil as arg' do
+      expect(described_class.invocation('executable.exe', nil)).to eq(%w(executable.exe))
+    end
+  end
+
+  context 'not on Windows' do
+    let(:windows?) { false }
+
+    before {
+      allow(Which).to receive(:which)
+    }
+
+    before {
+      @cmd = described_class.invocation('executable.exe')
+    }
+
+    it "should prepend 'mono'" do
+      expect(@cmd.first).to eq('mono')
+    end
+
+    it 'should resolve executable through which' do
+      expect(Which).to have_received(:which).with('executable.exe')
+    end
+
+    it 'should support args' do
+      expect(described_class.invocation(%w(executable.exe arg1 arg2))).to eq(%w(mono executable.exe arg1 arg2))
+    end
+  end
+end