rake-funnel 0.3.2.pre → 0.4.0.pre

data/spec/rake/funnel/support/internal/instantiate_symbol_spec.rb

@@ -1,183 +1,182 @@
-describe Rake::Funnel::Support::InstantiateSymbol do
-  module Creatable
-    class One
-    end
-
-    class Two
-    end
-
-    class Three
-    end
-  end
-
-  class ExplicitModuleDefinition
-    include Rake::Funnel::Support::InstantiateSymbol
-    instantiate Creatable
-
-    class Nested
-    end
-  end
-
-  class ImplicitModuleDefinition
-    include Rake::Funnel::Support::InstantiateSymbol
-
-    class Nested
-    end
-  end
-
-  describe 'module methods' do
-    subject {
-      ExplicitModuleDefinition.new
-    }
-
-    describe 'instance methods' do
-      it 'should not be public' do
-        expect(subject).not_to respond_to(:create)
-        expect(subject).not_to respond_to(:available)
-      end
-    end
-
-    describe 'class methods' do
-      it 'should not be public' do
-        expect(subject.class).not_to respond_to(:instantiate)
-      end
-    end
-  end
-
-  describe 'inspection' do
-    context 'implicit module' do
-      subject {
-        ImplicitModuleDefinition.new
-      }
-
-      it 'should yield constants in self' do
-        expect(subject.send(:available)).to eq([:ClassMethods, :Nested])
-      end
-    end
-
-    context 'explicit module' do
-      subject {
-        ExplicitModuleDefinition.new
-      }
-
-      it 'should yield sorted constants in module' do
-        expect(subject.send(:available)).to eq([:One, :Three, :Two])
-      end
-    end
-
-    context 'multiple uses' do
-      subject {
-        [
-          ExplicitModuleDefinition.new,
-          ImplicitModuleDefinition.new
-        ]
-      }
-
-      it 'should not overlap' do
-        first = subject[0].send(:available)
-        second = subject[1].send(:available)
-
-        expect(first).not_to include(second)
-      end
-    end
-  end
-
-  describe 'instantiation' do
-    subject {
-      ExplicitModuleDefinition.new
-    }
-
-    context 'with instance' do
-      it 'should return instance' do
-        instance = Object.new
-
-        expect(subject.send(:create, instance)).to eq(instance)
-      end
-    end
-
-
-    context 'with nil' do
-      it 'should return nil' do
-        expect(subject.send(:create, nil)).to eq(nil)
-      end
-    end
-
-    context 'symbol not defined' do
-      it 'should fail' do
-        expect { subject.send(:create, :does_not_exist) }.to raise_error 'Unknown type to instantiate: :does_not_exist. Available types are: [:One, :Three, :Two]'
-      end
-    end
-
-    context 'instantiation fails' do
-      class WillFail
-        include Rake::Funnel::Support::InstantiateSymbol
-
-        class Failure
-          def initialize
-            raise "BAM!"
-          end
-        end
-      end
-
-      subject {
-        WillFail.new
-      }
-
-      it 'should fail' do
-        expect { subject.send(:create, :Failure) }.to raise_error "BAM!"
-      end
-    end
-
-    context 'instantiation succeeds' do
-      it 'should return instance' do
-        expect(subject.send(:create, :One)).to be_an_instance_of(Creatable::One)
-      end
-    end
-
-    describe 'args' do
-      module CreatableWithArgs
-        class None
-          def initialize
-          end
-        end
-
-        class Single
-          def initialize(arg)
-          end
-        end
-
-        class Multiple
-          def initialize(arg1, arg2)
-          end
-        end
-      end
-
-      class WithArgs
-        include Rake::Funnel::Support::InstantiateSymbol
-        instantiate CreatableWithArgs
-      end
-
-      subject {
-        WithArgs.new
-      }
-
-      context 'no argument' do
-        it 'should not pass arg' do
-          expect(subject.send(:create, :None)).to be_an_instance_of(CreatableWithArgs::None)
-        end
-      end
-
-      context 'single argument' do
-        it 'should pass arg' do
-          expect(subject.send(:create, :Single, 1)).to be_an_instance_of(CreatableWithArgs::Single)
-        end
-      end
-
-      context 'multiple argument' do
-        it 'should pass args' do
-          expect(subject.send(:create, :Multiple, 1, 2)).to be_an_instance_of(CreatableWithArgs::Multiple)
-        end
-      end
-    end
-  end
-end
+describe Rake::Funnel::Support::InstantiateSymbol do
+  module Creatable
+    class One
+    end
+
+    class Two
+    end
+
+    class Three
+    end
+  end
+
+  class ExplicitModuleDefinition
+    include Rake::Funnel::Support::InstantiateSymbol
+    instantiate Creatable
+
+    class Nested
+    end
+  end
+
+  class ImplicitModuleDefinition
+    include Rake::Funnel::Support::InstantiateSymbol
+
+    class Nested
+    end
+  end
+
+  describe 'module methods' do
+    subject {
+      ExplicitModuleDefinition.new
+    }
+
+    describe 'instance methods' do
+      it 'should not be public' do
+        expect(subject).not_to respond_to(:create)
+        expect(subject).not_to respond_to(:available)
+      end
+    end
+
+    describe 'class methods' do
+      it 'should not be public' do
+        expect(subject.class).not_to respond_to(:instantiate)
+      end
+    end
+  end
+
+  describe 'inspection' do
+    context 'implicit module' do
+      subject {
+        ImplicitModuleDefinition.new
+      }
+
+      it 'should yield constants in self' do
+        expect(subject.send(:available)).to eq([:ClassMethods, :Nested])
+      end
+    end
+
+    context 'explicit module' do
+      subject {
+        ExplicitModuleDefinition.new
+      }
+
+      it 'should yield sorted constants in module' do
+        expect(subject.send(:available)).to eq([:One, :Three, :Two])
+      end
+    end
+
+    context 'multiple uses' do
+      subject {
+        [
+          ExplicitModuleDefinition.new,
+          ImplicitModuleDefinition.new
+        ]
+      }
+
+      it 'should not overlap' do
+        first = subject[0].send(:available)
+        second = subject[1].send(:available)
+
+        expect(first).not_to include(second)
+      end
+    end
+  end
+
+  describe 'instantiation' do
+    subject {
+      ExplicitModuleDefinition.new
+    }
+
+    context 'with instance' do
+      it 'should return instance' do
+        instance = Object.new
+
+        expect(subject.send(:create, instance)).to eq(instance)
+      end
+    end
+
+    context 'with nil' do
+      it 'should return nil' do
+        expect(subject.send(:create, nil)).to eq(nil)
+      end
+    end
+
+    context 'symbol not defined' do
+      it 'should fail' do
+        expect { subject.send(:create, :does_not_exist) }.to raise_error 'Unknown type to instantiate: :does_not_exist. Available types are: [:One, :Three, :Two]'
+      end
+    end
+
+    context 'instantiation fails' do
+      class WillFail
+        include Rake::Funnel::Support::InstantiateSymbol
+
+        class Failure
+          def initialize
+            fail 'BAM!'
+          end
+        end
+      end
+
+      subject {
+        WillFail.new
+      }
+
+      it 'should fail' do
+        expect { subject.send(:create, :Failure) }.to raise_error 'BAM!'
+      end
+    end
+
+    context 'instantiation succeeds' do
+      it 'should return instance' do
+        expect(subject.send(:create, :One)).to be_an_instance_of(Creatable::One)
+      end
+    end
+
+    describe 'args' do
+      module CreatableWithArgs
+        class None
+          def initialize
+          end
+        end
+
+        class Single
+          def initialize(_arg)
+          end
+        end
+
+        class Multiple
+          def initialize(_arg1, _arg2)
+          end
+        end
+      end
+
+      class WithArgs
+        include Rake::Funnel::Support::InstantiateSymbol
+        instantiate CreatableWithArgs
+      end
+
+      subject {
+        WithArgs.new
+      }
+
+      context 'no argument' do
+        it 'should not pass arg' do
+          expect(subject.send(:create, :None)).to be_an_instance_of(CreatableWithArgs::None)
+        end
+      end
+
+      context 'single argument' do
+        it 'should pass arg' do
+          expect(subject.send(:create, :Single, 1)).to be_an_instance_of(CreatableWithArgs::Single)
+        end
+      end
+
+      context 'multiple argument' do
+        it 'should pass args' do
+          expect(subject.send(:create, :Multiple, 1, 2)).to be_an_instance_of(CreatableWithArgs::Multiple)
+        end
+      end
+    end
+  end
+end

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

@@ -1,87 +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(NameError)
-      end
-    end
-
-    context 'nil mapper' do
-      it 'should fail' do
-        expect { described_class.new(nil) }.to raise_error(/You cannot use the 'nil' mapper style. Available mappers are:/)
-      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
+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(NameError)
+      end
+    end
+
+    context 'nil mapper' do
+      it 'should fail' do
+        expect { described_class.new(nil) }.to raise_error(/You cannot use the 'nil' mapper style. Available mappers are:/)
+      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/mono_spec.rb

@@ -1,57 +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
+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