rake-funnel 0.3.2.pre → 0.4.0.pre

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

@@ -1,65 +1,65 @@
-require 'tmpdir'
-
-describe Rake::Funnel::Support::Which do
-  let(:temp_dir) { Dir.mktmpdir }
-  let(:executable_path) { File.join(temp_dir, 'executable.exe') }
-  let(:create_entry) { lambda { |p| FileUtils.touch(p) }}
-
-  before {
-    create_entry.call(executable_path)
-
-    allow(ENV).to receive(:[]).with('PATH').and_return(temp_dir)
-  }
-
-  after {
-    FileUtils.rm_rf(temp_dir)
-  }
-
-  describe 'executable in PATH' do
-    context 'found' do
-      it 'should yield executable' do
-        expect(described_class.which(File.basename(executable_path))).to eq(executable_path)
-      end
-    end
-
-    context 'not found' do
-      it 'should yield nil' do
-        expect(described_class.which('does-not-exist.exe')).to be_nil
-      end
-    end
-
-    context 'found as directory' do
-      let(:create_entry) { lambda { |p| FileUtils.mkdir_p(p) } }
-
-      it 'should yield nil' do
-        expect(described_class.which('executable.exe')).to be_nil
-      end
-    end
-  end
-
-  describe 'executable in current working directory' do
-    context 'found' do
-      it 'should yield executable' do
-        Dir.chdir(temp_dir) do
-          expect(described_class.which(File.basename(executable_path))).to eq(File.basename(executable_path))
-        end
-      end
-    end
-
-    context 'not found' do
-      it 'should yield nil' do
-        Dir.chdir(temp_dir) do
-          expect(described_class.which('does-not-exist.exe')).to be_nil
-        end
-      end
-    end
-
-    context 'found as directory' do
-      let(:create_entry) { lambda { |p| FileUtils.mkdir_p(p) } }
-
-      it 'should yield nil' do
-        expect(described_class.which('executable.exe')).to be_nil
-      end
-    end
-  end
-end
+require 'tmpdir'
+
+describe Rake::Funnel::Support::Which do
+  let(:temp_dir) { Dir.mktmpdir }
+  let(:executable_path) { File.join(temp_dir, 'executable.exe') }
+  let(:create_entry) { lambda { |p| FileUtils.touch(p) }}
+
+  before {
+    create_entry.call(executable_path)
+
+    allow(ENV).to receive(:[]).with('PATH').and_return(temp_dir)
+  }
+
+  after {
+    FileUtils.rm_rf(temp_dir)
+  }
+
+  describe 'executable in PATH' do
+    context 'found' do
+      it 'should yield executable' do
+        expect(described_class.which(File.basename(executable_path))).to eq(executable_path)
+      end
+    end
+
+    context 'not found' do
+      it 'should yield nil' do
+        expect(described_class.which('does-not-exist.exe')).to be_nil
+      end
+    end
+
+    context 'found as directory' do
+      let(:create_entry) { lambda { |p| FileUtils.mkdir_p(p) } }
+
+      it 'should yield nil' do
+        expect(described_class.which('executable.exe')).to be_nil
+      end
+    end
+  end
+
+  describe 'executable in current working directory' do
+    context 'found' do
+      it 'should yield executable' do
+        Dir.chdir(temp_dir) do
+          expect(described_class.which(File.basename(executable_path))).to eq(File.basename(executable_path))
+        end
+      end
+    end
+
+    context 'not found' do
+      it 'should yield nil' do
+        Dir.chdir(temp_dir) do
+          expect(described_class.which('does-not-exist.exe')).to be_nil
+        end
+      end
+    end
+
+    context 'found as directory' do
+      let(:create_entry) { lambda { |p| FileUtils.mkdir_p(p) } }
+
+      it 'should yield nil' do
+        expect(described_class.which('executable.exe')).to be_nil
+      end
+    end
+  end
+end

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

@@ -1,77 +1,77 @@
-include Rake::Funnel::Support
-
-describe Rake::Funnel::Support::Zipper do
-  describe '#zip' do
-    let(:source) { %w(bin/1 bin/2 bin/3/4) }
-
-    context 'failure' do
-      context 'target not defined' do
-        let(:target) { nil }
-
-        it 'should fail' do
-          expect { described_class.zip(source, target) }.to raise_error(/Target not defined/)
-        end
-      end
-    end
-
-    context 'success' do
-      let(:target) { 'some path/file.zip' }
-      let(:zip_root) { nil }
-      let(:zip) { instance_double(::Zip::File).as_null_object }
-      let(:mtime) { Time.new(2015, 3, 9) }
-      let(:zip_entry) { double(::Zip::Entry).as_null_object }
-
-      before {
-        allow(RakeFileUtils).to receive(:mkdir_p)
-      }
-
-      before {
-        allow(::Zip::File).to receive(:open).with(target, ::Zip::File::CREATE).and_yield(zip)
-        allow(zip).to receive(:add).and_return(zip_entry)
-        allow(File).to receive(:mtime).and_return(mtime)
-      }
-
-      before {
-        described_class.zip(source, target, zip_root)
-      }
-
-      it 'should create the target directory' do
-        expect(RakeFileUtils).to have_received(:mkdir_p).with(File.dirname(target))
-      end
-
-      describe 'configuration' do
-        it 'should allow unicode names' do
-          expect(::Zip.unicode_names).to eq(true)
-        end
-
-        it 'should use best compression' do
-          expect(::Zip.default_compression).to eq(Zlib::BEST_COMPRESSION)
-        end
-      end
-
-      describe 'work-around for https://github.com/rubyzip/rubyzip/issues/176' do
-        it 'should explicitly set the file mtime' do
-          expect(zip_entry).to have_received(:time=).with(mtime).exactly(source.length).times
-        end
-      end
-
-      describe 'common path' do
-        it 'should remove the common path from the source' do
-          expect(zip).not_to have_received(:add).with(/#{source.common_path}/, anything)
-        end
-      end
-
-      describe 'zip root' do
-        [nil, '', 'some path/inside the zip file'].each do |root|
-          context "with '#{root || 'nil'}'" do
-            let(:zip_root) { root }
-
-            it "should put files below #{(root.nil? || root.empty?) ? 'the root' : "'#{root}'"}" do
-              expect(zip).to have_received(:add).with(/^#{root}/, anything).exactly(source.length).times
-            end
-          end
-        end
-      end
-    end
-  end
-end
+include Rake::Funnel::Support
+
+describe Rake::Funnel::Support::Zipper do
+  describe '#zip' do
+    let(:source) { %w(bin/1 bin/2 bin/3/4) }
+
+    context 'failure' do
+      context 'target not defined' do
+        let(:target) { nil }
+
+        it 'should fail' do
+          expect { described_class.zip(source, target) }.to raise_error(/Target not defined/)
+        end
+      end
+    end
+
+    context 'success' do
+      let(:target) { 'some path/file.zip' }
+      let(:zip_root) { nil }
+      let(:zip) { instance_double(::Zip::File).as_null_object }
+      let(:mtime) { Time.new(2015, 3, 9) }
+      let(:zip_entry) { double(::Zip::Entry).as_null_object }
+
+      before {
+        allow(RakeFileUtils).to receive(:mkdir_p)
+      }
+
+      before {
+        allow(::Zip::File).to receive(:open).with(target, ::Zip::File::CREATE).and_yield(zip)
+        allow(zip).to receive(:add).and_return(zip_entry)
+        allow(File).to receive(:mtime).and_return(mtime)
+      }
+
+      before {
+        described_class.zip(source, target, zip_root)
+      }
+
+      it 'should create the target directory' do
+        expect(RakeFileUtils).to have_received(:mkdir_p).with(File.dirname(target))
+      end
+
+      describe 'configuration' do
+        it 'should allow unicode names' do
+          expect(::Zip.unicode_names).to eq(true)
+        end
+
+        it 'should use best compression' do
+          expect(::Zip.default_compression).to eq(Zlib::BEST_COMPRESSION)
+        end
+      end
+
+      describe 'work-around for https://github.com/rubyzip/rubyzip/issues/176' do
+        it 'should explicitly set the file mtime' do
+          expect(zip_entry).to have_received(:time=).with(mtime).exactly(source.length).times
+        end
+      end
+
+      describe 'common path' do
+        it 'should remove the common path from the source' do
+          expect(zip).not_to have_received(:add).with(/#{source.common_path}/, anything)
+        end
+      end
+
+      describe 'zip root' do
+        [nil, '', 'some path/inside the zip file'].each do |root|
+          context "with '#{root || 'nil'}'" do
+            let(:zip_root) { root }
+
+            it "should put files below #{(root.nil? || root.empty?) ? 'the root' : "'#{root}'"}" do
+              expect(zip).to have_received(:add).with(/^#{root}/, anything).exactly(source.length).times
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -1,45 +1,45 @@
-include Rake
-include Rake::Funnel::Support
-
-describe Rake::Funnel::Tasks::AssemblyVersion do
-  before {
-    Task.clear
-  }
-
-  describe 'defaults' do
-    its(:name) { should == :version }
-    its(:language) { should == :cs }
-    its(:source) { should == :FromVersionFiles }
-    its(:source_args) { should == {} }
-    its(:target_path) { should be_an_instance_of(Proc) }
-  end
-
-  describe 'execution' do
-    let(:writer) { instance_double(AssemblyVersionWriter).as_null_object }
-
-    before {
-      allow(AssemblyVersionWriter).to receive(:new).and_return(writer)
-    }
-
-    subject {
-      described_class.new(:name) do |t|
-        t.language = [:cs, :vb]
-        t.source = %w(one two)
-        t.source_args = { foo: 42 }
-        t.target_path = 'will not work'
-      end
-    }
-
-    before {
-      Task[subject.name].invoke
-    }
-
-    it 'should pass source and source_args' do
-      expect(AssemblyVersionWriter).to have_received(:new).with(subject.source, subject.source_args)
-    end
-
-    it 'should use writer' do
-      expect(writer).to have_received(:write).with(subject.target_path, subject.language)
-    end
-  end
-end
+include Rake
+include Rake::Funnel::Support
+
+describe Rake::Funnel::Tasks::AssemblyVersion do
+  before {
+    Task.clear
+  }
+
+  describe 'defaults' do
+    its(:name) { should == :version }
+    its(:language) { should == :cs }
+    its(:source) { should == :FromVersionFiles }
+    its(:source_args) { should == {} }
+    its(:target_path) { should be_an_instance_of(Proc) }
+  end
+
+  describe 'execution' do
+    let(:writer) { instance_double(AssemblyVersionWriter).as_null_object }
+
+    before {
+      allow(AssemblyVersionWriter).to receive(:new).and_return(writer)
+    }
+
+    subject {
+      described_class.new(:name) do |t|
+        t.language = [:cs, :vb]
+        t.source = %w(one two)
+        t.source_args = { foo: 42 }
+        t.target_path = 'will not work'
+      end
+    }
+
+    before {
+      Task[subject.name].invoke
+    }
+
+    it 'should pass source and source_args' do
+      expect(AssemblyVersionWriter).to have_received(:new).with(subject.source, subject.source_args)
+    end
+
+    it 'should use writer' do
+      expect(writer).to have_received(:write).with(subject.target_path, subject.language)
+    end
+  end
+end

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

@@ -1,52 +1,52 @@
-include Rake
-
-describe Rake::Funnel::Tasks::BinPath do
-  before {
-    Task.clear
-  }
-
-  describe 'defaults' do
-    its(:name) { should == :bin_path }
-    its(:search_pattern) { should eq(%w(tools/* tools/*/bin packages/**/tools)) }
-  end
-
-  describe 'execution' do
-    let(:default_path) { 'default PATH contents' }
-    let(:search_pattern) { %w(foo bar) }
-
-    before {
-      allow(ENV).to receive(:[]).with('PATH').and_return(default_path)
-      allow(ENV).to receive(:[]=)
-      allow(Rake).to receive(:rake_output_message)
-    }
-
-    before {
-      allow(Dir).to receive(:[]).with(*search_pattern).and_return(search_pattern)
-    }
-
-    subject {
-      described_class.new do |t|
-        t.search_pattern = search_pattern
-      end
-    }
-
-    before {
-      Task[subject.name].invoke
-    }
-
-    it 'should prepend sorted matching folders to the PATH environment variable' do
-      paths = search_pattern.map { |path| File.expand_path(path) }.sort.join(File::PATH_SEPARATOR)
-
-      expect(ENV).to have_received(:[]=).with('PATH',/^#{paths}/)
-    end
-
-    it 'should append original PATH environment variable' do
-      expect(ENV).to have_received(:[]=).with('PATH', /#{default_path}$/)
-    end
-
-    it 'should report added paths' do
-      expect(Rake).to have_received(:rake_output_message).with(%r|/foo$|)
-      expect(Rake).to have_received(:rake_output_message).with(%r|/bar$|)
-    end
-  end
-end
+include Rake
+
+describe Rake::Funnel::Tasks::BinPath do
+  before {
+    Task.clear
+  }
+
+  describe 'defaults' do
+    its(:name) { should == :bin_path }
+    its(:search_pattern) { should eq(%w(tools/* tools/*/bin packages/**/tools)) }
+  end
+
+  describe 'execution' do
+    let(:default_path) { 'default PATH contents' }
+    let(:search_pattern) { %w(foo bar) }
+
+    before {
+      allow(ENV).to receive(:[]).with('PATH').and_return(default_path)
+      allow(ENV).to receive(:[]=)
+      allow(Rake).to receive(:rake_output_message)
+    }
+
+    before {
+      allow(Dir).to receive(:[]).with(*search_pattern).and_return(search_pattern)
+    }
+
+    subject {
+      described_class.new do |t|
+        t.search_pattern = search_pattern
+      end
+    }
+
+    before {
+      Task[subject.name].invoke
+    }
+
+    it 'should prepend sorted matching folders to the PATH environment variable' do
+      paths = search_pattern.map { |path| File.expand_path(path) }.sort.join(File::PATH_SEPARATOR)
+
+      expect(ENV).to have_received(:[]=).with('PATH',/^#{paths}/)
+    end
+
+    it 'should append original PATH environment variable' do
+      expect(ENV).to have_received(:[]=).with('PATH', /#{default_path}$/)
+    end
+
+    it 'should report added paths' do
+      expect(Rake).to have_received(:rake_output_message).with(%r|/foo$|)
+      expect(Rake).to have_received(:rake_output_message).with(%r|/bar$|)
+    end
+  end
+end

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

@@ -1,44 +1,44 @@
-include Rake
-include Rake::Funnel::Support
-
-describe Rake::Funnel::Tasks::Copy do
-  before {
-    Task.clear
-  }
-
-  describe 'defaults' do
-    its(:name) { should == :copy }
-    its(:source) { should eq([]) }
-    its(:target) { should be_nil }
-  end
-
-  describe 'execution' do
-    let(:source) { %w(one two) }
-    let(:target) { 'target' }
-    let(:finder) { instance_double(Finder).as_null_object }
-
-    before {
-      allow(finder).to receive(:all_or_default).and_return(source)
-      allow(Finder).to receive(:new).and_return(finder)
-    }
-
-    before {
-      allow(Copier).to receive(:copy)
-    }
-
-    subject {
-      described_class.new do |t|
-        t.source = source
-        t.target = target
-      end
-    }
-
-    before {
-      Task[subject.name].invoke
-    }
-
-    it 'should delegate to Copier' do
-      expect(Copier).to have_received(:copy).with(source, subject.target)
-    end
-  end
-end
+include Rake
+include Rake::Funnel::Support
+
+describe Rake::Funnel::Tasks::Copy do
+  before {
+    Task.clear
+  }
+
+  describe 'defaults' do
+    its(:name) { should == :copy }
+    its(:source) { should eq([]) }
+    its(:target) { should be_nil }
+  end
+
+  describe 'execution' do
+    let(:source) { %w(one two) }
+    let(:target) { 'target' }
+    let(:finder) { instance_double(Finder).as_null_object }
+
+    before {
+      allow(finder).to receive(:all_or_default).and_return(source)
+      allow(Finder).to receive(:new).and_return(finder)
+    }
+
+    before {
+      allow(Copier).to receive(:copy)
+    }
+
+    subject {
+      described_class.new do |t|
+        t.source = source
+        t.target = target
+      end
+    }
+
+    before {
+      Task[subject.name].invoke
+    }
+
+    it 'should delegate to Copier' do
+      expect(Copier).to have_received(:copy).with(source, subject.target)
+    end
+  end
+end