rake-funnel 0.3.2.pre → 0.4.0.pre

data/spec/rake/funnel/tasks/paket_spec.rb

@@ -1,142 +1,140 @@
-include Rake
-include Rake::Funnel::Support
-
-describe Rake::Funnel::Tasks::Paket do
-  before {
-    Task.clear
-  }
-
-  describe 'defaults' do
-    its(:name) { should == :paket }
-    its(:paket) { should == '.paket/paket.exe' }
-    its(:paket_args) { should == 'restore' }
-    its(:bootstrapper) { should == '.paket/paket.bootstrapper.exe' }
-    its(:bootstrapper_args) { should == nil }
-  end
-
-  describe 'execution' do
-    before {
-      allow(subject).to receive(:sh)
-      allow(Mono).to receive(:invocation).and_wrap_original do |_original_method, *args, &_block|
-        args.compact
-      end
-    }
-
-    context 'overriding defaults' do
-      subject {
-        described_class.new do |t|
-          t.bootstrapper = 'custom bootstrapper.exe'
-          t.bootstrapper_args = %w(arg1 arg2)
-          t.paket = 'custom paket.exe'
-          t.paket_args = %w(arg1 arg2)
-        end
-      }
-
-      before {
-        allow(File).to receive(:exist?).and_return(false)
-        allow(subject).to receive(:sh)
-      }
-
-      before {
-        Task[subject.name].invoke
-      }
-
-      it 'should use custom bootstrapper' do
-        expect(subject).to have_received(:sh).with(subject.bootstrapper, subject.bootstrapper_args)
-      end
-
-      it 'should use custom paket' do
-        expect(subject).to have_received(:sh).with(subject.paket, subject.paket_args)
-      end
-    end
-
-    describe 'mono invocation' do
-      before {
-        Task[subject.name].invoke
-      }
-
-      it 'should use mono invocation for bootstrapper' do
-        expect(Mono).to have_received(:invocation).with(subject.bootstrapper, subject.bootstrapper_args)
-      end
-
-      it 'should use mono invocation for paket' do
-        expect(Mono).to have_received(:invocation).with(subject.paket, subject.paket_args)
-      end
-    end
-
-    describe 'optional download' do
-      before {
-        allow(File).to receive(:exist?).with(subject.paket).and_return(paket_exists)
-        allow(subject).to receive(:sh).with(subject.bootstrapper)
-      }
-
-      context 'success' do
-        before {
-          Task[subject.name].invoke
-        }
-
-        context 'paket.exe exists' do
-          let(:paket_exists) { true }
-
-          it 'should not run bootstrapper' do
-            expect(subject).not_to have_received(:sh).with(subject.bootstrapper)
-          end
-
-          it 'should run paket' do
-            expect(subject).to have_received(:sh).with(subject.paket, subject.paket_args)
-          end
-        end
-
-        context 'paket.exe does not exist' do
-          let(:paket_exists) { false }
-
-          it 'should run bootstrapper' do
-            expect(subject).to have_received(:sh).with(subject.bootstrapper)
-          end
-
-          it 'should run paket' do
-            expect(subject).to have_received(:sh).with(subject.paket, subject.paket_args)
-          end
-        end
-      end
-
-      context 'failure' do
-
-
-        context 'paket.exe exists' do
-          let(:paket_exists) { true }
-
-          context 'paket failed' do
-            before {
-              allow(subject).to receive(:sh).with(subject.paket, anything).and_raise
-            }
-
-            it 'should fail' do
-              expect { Task[subject.name].invoke }.to raise_error
-            end
-          end
-        end
-
-        context 'paket.exe does not exist' do
-          let(:paket_exists) { false }
-
-          context 'bootstrapper failed' do
-            before {
-              allow(subject).to receive(:sh).with(subject.bootstrapper).and_raise
-            }
-
-            it 'should not run paket' do
-              Task[subject.name].invoke rescue nil
-
-              expect(subject).not_to have_received(:sh).with(subject.paket, subject.paket_args)
-            end
-
-            it 'should fail' do
-              expect { Task[subject.name].invoke }.to raise_error
-            end
-          end
-        end
-      end
-    end
-  end
-end
+include Rake
+include Rake::Funnel::Support
+
+describe Rake::Funnel::Tasks::Paket do
+  before {
+    Task.clear
+  }
+
+  describe 'defaults' do
+    its(:name) { should == :paket }
+    its(:paket) { should == '.paket/paket.exe' }
+    its(:paket_args) { should == 'restore' }
+    its(:bootstrapper) { should == '.paket/paket.bootstrapper.exe' }
+    its(:bootstrapper_args) { should be_nil }
+  end
+
+  describe 'execution' do
+    before {
+      allow(subject).to receive(:sh)
+      allow(Mono).to receive(:invocation).and_wrap_original do |_original_method, *args, &_block|
+        args.compact
+      end
+    }
+
+    context 'overriding defaults' do
+      subject {
+        described_class.new do |t|
+          t.bootstrapper = 'custom bootstrapper.exe'
+          t.bootstrapper_args = %w(arg1 arg2)
+          t.paket = 'custom paket.exe'
+          t.paket_args = %w(arg1 arg2)
+        end
+      }
+
+      before {
+        allow(File).to receive(:exist?).and_return(false)
+        allow(subject).to receive(:sh)
+      }
+
+      before {
+        Task[subject.name].invoke
+      }
+
+      it 'should use custom bootstrapper' do
+        expect(subject).to have_received(:sh).with(subject.bootstrapper, subject.bootstrapper_args)
+      end
+
+      it 'should use custom paket' do
+        expect(subject).to have_received(:sh).with(subject.paket, subject.paket_args)
+      end
+    end
+
+    describe 'mono invocation' do
+      before {
+        Task[subject.name].invoke
+      }
+
+      it 'should use mono invocation for bootstrapper' do
+        expect(Mono).to have_received(:invocation).with(subject.bootstrapper, subject.bootstrapper_args)
+      end
+
+      it 'should use mono invocation for paket' do
+        expect(Mono).to have_received(:invocation).with(subject.paket, subject.paket_args)
+      end
+    end
+
+    describe 'optional download' do
+      before {
+        allow(File).to receive(:exist?).with(subject.paket).and_return(paket_exists)
+        allow(subject).to receive(:sh).with(subject.bootstrapper)
+      }
+
+      context 'success' do
+        before {
+          Task[subject.name].invoke
+        }
+
+        context 'paket.exe exists' do
+          let(:paket_exists) { true }
+
+          it 'should not run bootstrapper' do
+            expect(subject).not_to have_received(:sh).with(subject.bootstrapper)
+          end
+
+          it 'should run paket' do
+            expect(subject).to have_received(:sh).with(subject.paket, subject.paket_args)
+          end
+        end
+
+        context 'paket.exe does not exist' do
+          let(:paket_exists) { false }
+
+          it 'should run bootstrapper' do
+            expect(subject).to have_received(:sh).with(subject.bootstrapper)
+          end
+
+          it 'should run paket' do
+            expect(subject).to have_received(:sh).with(subject.paket, subject.paket_args)
+          end
+        end
+      end
+
+      context 'failure' do
+        context 'paket.exe exists' do
+          let(:paket_exists) { true }
+
+          context 'paket failed' do
+            before {
+              allow(subject).to receive(:sh).with(subject.paket, anything).and_raise
+            }
+
+            it 'should fail' do
+              expect { Task[subject.name].invoke }.to raise_error
+            end
+          end
+        end
+
+        context 'paket.exe does not exist' do
+          let(:paket_exists) { false }
+
+          context 'bootstrapper failed' do
+            before {
+              allow(subject).to receive(:sh).with(subject.bootstrapper).and_raise
+            }
+
+            it 'should not run paket' do
+              Task[subject.name].invoke rescue nil
+
+              expect(subject).not_to have_received(:sh).with(subject.paket, subject.paket_args)
+            end
+
+            it 'should fail' do
+              expect { Task[subject.name].invoke }.to raise_error
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/rake/funnel/tasks/quick_template_spec.rb

@@ -1,62 +1,62 @@
-require 'tmpdir'
-
-include Rake
-include Rake::Funnel::Support
-
-describe Rake::Funnel::Tasks::QuickTemplate do
-  before {
-    Task.clear
-  }
-
-  describe 'defaults' do
-    its(:name) { should == :template }
-    its(:search_pattern) { should eq(%w(**/*.erb)) }
-    its(:context) { should kind_of?(Binding) }
-  end
-
-  describe 'execution' do
-    let(:templates) { %w(1.template two/2.template) }
-
-    let(:finder) { double(Finder).as_null_object }
-    let(:engine) { TemplateEngine }
-
-    before {
-      allow(finder).to receive(:all_or_default).and_return(templates)
-      allow(Finder).to receive(:new).and_return(finder)
-      allow(engine).to receive(:render).and_return('file content')
-      allow(Rake).to receive(:rake_output_message)
-      allow(File).to receive(:read).and_return('template content')
-      allow(File).to receive(:write)
-    }
-
-    subject! { described_class.new }
-
-    before {
-      Task[subject.name].invoke
-    }
-
-    it 'should report created files' do
-      templates.each do |template|
-        expect(Rake).to have_received(:rake_output_message).with("Creating file #{template.ext}")
-      end
-    end
-
-    it 'should read all templates' do
-      templates.each do |template|
-        expect(File).to have_received(:read).with(template)
-      end
-    end
-
-    it 'should render all templates' do
-      templates.each do |template|
-        expect(engine).to have_received(:render).with('template content', template, subject.context)
-      end
-    end
-
-    it 'should write all files' do
-      templates.each do |template|
-        expect(File).to have_received(:write).with(template.ext, 'file content')
-      end
-    end
-  end
-end
+require 'tmpdir'
+
+include Rake
+include Rake::Funnel::Support
+
+describe Rake::Funnel::Tasks::QuickTemplate do
+  before {
+    Task.clear
+  }
+
+  describe 'defaults' do
+    its(:name) { should == :template }
+    its(:search_pattern) { should eq(%w(**/*.erb)) }
+    its(:context) { should be_an_instance_of(Binding) }
+  end
+
+  describe 'execution' do
+    let(:templates) { %w(1.template two/2.template) }
+
+    let(:finder) { double(Finder).as_null_object }
+    let(:engine) { TemplateEngine }
+
+    before {
+      allow(finder).to receive(:all_or_default).and_return(templates)
+      allow(Finder).to receive(:new).and_return(finder)
+      allow(engine).to receive(:render).and_return('file content')
+      allow(Rake).to receive(:rake_output_message)
+      allow(File).to receive(:read).and_return('template content')
+      allow(File).to receive(:write)
+    }
+
+    subject! { described_class.new }
+
+    before {
+      Task[subject.name].invoke
+    }
+
+    it 'should report created files' do
+      templates.each do |template|
+        expect(Rake).to have_received(:rake_output_message).with("Creating file #{template.ext}")
+      end
+    end
+
+    it 'should read all templates' do
+      templates.each do |template|
+        expect(File).to have_received(:read).with(template)
+      end
+    end
+
+    it 'should render all templates' do
+      templates.each do |template|
+        expect(engine).to have_received(:render).with('template content', template, subject.context)
+      end
+    end
+
+    it 'should write all files' do
+      templates.each do |template|
+        expect(File).to have_received(:write).with(template.ext, 'file content')
+      end
+    end
+  end
+end

data/spec/rake/funnel/tasks/side_by_side_specs_spec.rb

@@ -1,58 +1,58 @@
-require 'tmpdir'
-
-include Rake
-include Rake::Funnel::Support
-
-describe Rake::Funnel::Tasks::SideBySideSpecs do
-  before {
-    Task.clear
-  }
-
-  describe 'defaults' do
-    its(:name) { should == :compile }
-    its(:projects) { should == %w(**/*.csproj **/*.vbproj **/*.fsproj) }
-    its(:references) { should == [] }
-    its(:specs) { should == %w(*Specs.cs **/*Specs.cs *Tests.cs **/*Tests.cs) }
-    its(:enabled) { should == false }
-  end
-
-  describe 'execution' do
-    subject {
-      described_class.new do |t|
-        t.projects = %w(**/*.??proj)
-        t.references = %w(Ref-1)
-        t.specs = %w(*Specs.cs **/*Specs.cs)
-        t.enabled = enabled
-      end
-    }
-
-    before {
-      allow(SpecsRemover).to receive(:remove)
-    }
-
-    before {
-      Task[subject.name].invoke
-    }
-
-    context 'enabled' do
-      let(:enabled) { true }
-
-      it 'should use remover' do
-        expect(SpecsRemover).to have_received(:remove)
-            .with({
-                projects: subject.projects,
-                references: subject.references,
-                specs: subject.specs
-              })
-      end
-    end
-
-    context 'disabled' do
-      let(:enabled) { false }
-
-      it 'should do nothing' do
-        expect(SpecsRemover).not_to have_received(:remove)
-      end
-    end
-  end
-end
+require 'tmpdir'
+
+include Rake
+include Rake::Funnel::Support
+
+describe Rake::Funnel::Tasks::SideBySideSpecs do
+  before {
+    Task.clear
+  }
+
+  describe 'defaults' do
+    its(:name) { should == :compile }
+    its(:projects) { should == %w(**/*.csproj **/*.vbproj **/*.fsproj) }
+    its(:references) { should == [] }
+    its(:specs) { should == %w(*Specs.cs **/*Specs.cs *Tests.cs **/*Tests.cs) }
+    its(:enabled) { should == false }
+  end
+
+  describe 'execution' do
+    subject {
+      described_class.new do |t|
+        t.projects = %w(**/*.??proj)
+        t.references = %w(Ref-1)
+        t.specs = %w(*Specs.cs **/*Specs.cs)
+        t.enabled = enabled
+      end
+    }
+
+    before {
+      allow(SpecsRemover).to receive(:remove)
+    }
+
+    before {
+      Task[subject.name].invoke
+    }
+
+    context 'enabled' do
+      let(:enabled) { true }
+
+      it 'should use remover' do
+        expect(SpecsRemover).to have_received(:remove)
+            .with({
+                projects: subject.projects,
+                references: subject.references,
+                specs: subject.specs
+              })
+      end
+    end
+
+    context 'disabled' do
+      let(:enabled) { false }
+
+      it 'should do nothing' do
+        expect(SpecsRemover).not_to have_received(:remove)
+      end
+    end
+  end
+end