rake-funnel 0.1.0.pre → 0.2.0.pre

data/lib/rake/funnel/tasks/quick_template.rb

@@ -7,28 +7,30 @@ module Rake::Funnel::Tasks
 
     attr_accessor :name, :search_pattern, :context
 
-    def initialize(name = :template)
-      @name = name
+    def initialize(*args, &task_block)
+      setup_ivars(args)
+
+      define(args, &task_block)
+    end
+
+    private
+    def setup_ivars(args)
+      @name = args.shift || :template
 
       @search_pattern = %w(**/*.erb)
       @context = binding
-
-      yield self if block_given?
-      define
     end
 
-    private
-    def define
-      results = templates.all_or_default.map { |t| result_filename(t) }
-      CLEAN.include(*results)
+    def define(args, &task_block)
+      desc 'Generate templates' unless Rake.application.last_description
+      task(name, *args) do |_, task_args|
+        task_block.call(*[self, task_args].slice(0, task_block.arity)) if task_block
 
-      desc "Generate #{templates.all_or_default.join(', ')}"
-      task name do
         templates.all_or_default.each do |template|
           target = result_filename(template)
           Rake.rake_output_message "Creating file #{target}"
 
-          content = Rake::Funnel::Support::TemplateEngine.render(File.read(template), template, context)
+          content = TemplateEngine.render(File.read(template), template, context)
           File.write(target, content)
         end
       end

data/lib/rake/funnel/tasks/side_by_side_specs.rb

@@ -2,27 +2,33 @@ require 'rake/tasklib'
 
 module Rake::Funnel::Tasks
   class SideBySideSpecs < Rake::TaskLib
-    include Rake::Funnel::Support::SideBySideSpecs
+    include Rake::Funnel::Support
 
     attr_accessor :name, :projects, :references, :specs, :enabled
 
-    def initialize(name = :compile)
-      @name = name
+    def initialize(*args, &task_block)
+      setup_ivars(args)
+
+      define(args, &task_block)
+    end
+
+    private
+    def setup_ivars(args)
+      @name = args.shift || :compile
 
       @projects = %w(**/*.csproj **/*.vbproj **/*.fsproj)
       @references = []
       @specs = %w(*Specs.cs **/*Specs.cs *Tests.cs **/*Tests.cs)
       @enabled = false
-
-      yield self if block_given?
-      define
     end
 
-    private
-    def define
-      task name do
+    def define(args, &task_block)
+      desc 'Remove tests from projects' unless Rake.application.last_description
+      task(name, *args) do |_, task_args|
+        task_block.call(*[self, task_args].slice(0, task_block.arity)) if task_block
+
         next unless enabled
-        Remover.remove({ projects: projects, references: references, specs: specs })
+        SpecsRemover.remove({ projects: projects, references: references, specs: specs })
       end
 
       self

data/lib/rake/funnel/tasks/timing.rb

@@ -7,13 +7,10 @@ module Rake::Funnel::Tasks
     attr_accessor :name
     attr_reader :stats
 
-    def initialize(name = :timing)
-      @name = name
-      @stats = Statistics.new
-
-      yield self if block_given?
+    def initialize(*args, &task_block)
+      setup_ivars(args)
 
-      define
+      define(args, &task_block)
     end
 
     def reset!
@@ -21,11 +18,21 @@ module Rake::Funnel::Tasks
     end
 
     private
-    def define
+    def setup_ivars(args)
+      @name = args.shift || :timing
+
+      @stats = Statistics.new
+    end
+
+    def define(args, &task_block)
       patches.each { |p| p.apply! }
 
-      task @name, :failed do |task, args|
-        Report.new(@stats, args).render
+      desc 'Output task timing information' unless Rake.application.last_description
+
+      task name, :failed do |_, task_args|
+        task_block.call(*[self, task_args].slice(0, task_block.arity)) if task_block
+
+        Report.new(@stats, task_args).render
       end
 
       timing_task = Rake.application.current_scope.path_with_task_name(@name)

data/lib/rake/funnel/tasks/zip.rb

@@ -1,6 +1,4 @@
-require 'pathname'
 require 'rake/tasklib'
-require 'zip'
 
 module Rake::Funnel::Tasks
   class Zip < Rake::TaskLib
@@ -8,30 +6,28 @@ module Rake::Funnel::Tasks
 
     attr_accessor :name, :source, :target, :zip_root
 
-    def initialize(name = :package)
-      @name = name
+    def initialize(*args, &task_block)
+      setup_ivars(args)
+
+      define(args, &task_block)
+    end
+
+    private
+    def setup_ivars(args)
+      @name = args.shift || :package
 
       @source = []
       @target = nil
       @zip_root = nil
-
-      yield self if block_given?
-      define
     end
 
-    private
-    def define
-      target && CLEAN.include(target)
-
-      desc "Zip #{files.join(', ')} to #{target}"
-      task name do
-        raise 'Target not defined' unless target
+    def define(args, &task_block)
+      desc 'Zip files' unless Rake.application.last_description
 
-        target_dir = File.dirname(target)
-        RakeFileUtils.mkdir_p(target_dir) unless File.directory?(target_dir)
+      task(name, *args) do |_, task_args|
+        task_block.call(*[self, task_args].slice(0, task_block.arity)) if task_block
 
-        configure_zip
-        create_zip(files, target)
+        Zipper.zip(files, target, zip_root)
 
         Rake.rake_output_message("Created #{target}")
       end
@@ -42,35 +38,5 @@ module Rake::Funnel::Tasks
     def files
       Finder.new(source, self, 'No files to zip.').all_or_default
     end
-
-    def configure_zip
-      ::Zip.unicode_names = true
-      ::Zip.default_compression = Zlib::BEST_COMPRESSION
-    end
-
-    def create_zip(files, target)
-      ::Zip::File.open(target, ::Zip::File::CREATE) do |zip|
-        common_path = files.common_path
-
-        files.each do |file|
-          zipped_file = get_zipped_path(common_path, file)
-
-          entry = zip.add(zipped_file, file)
-          set_mtime(entry, file)
-        end
-      end
-    end
-
-    # To work around this bug: https://github.com/rubyzip/rubyzip/issues/176
-    def set_mtime(entry, file)
-      entry.time = ::Zip::DOSTime.at(File.mtime(file))
-      entry.extra.delete('UniversalTime')
-    end
-
-    def get_zipped_path(common_path, file)
-      file = Pathname.new(file).relative_path_from(Pathname.new(common_path)).to_s unless common_path.nil?
-      file = File.join(zip_root, file) unless zip_root.nil? || zip_root.empty?
-      file
-    end
   end
 end

data/lib/rake/funnel/version.rb

@@ -1,5 +1,5 @@
 module Rake
   module Funnel
-    VERSION = '0.1.0.pre'
+    VERSION = '0.2.0.pre'
   end
 end

data/spec/rake/funnel/integration/teamcity/nunit_plugin_spec.rb

@@ -1,29 +1,24 @@
 include Rake::Funnel::Support
 
 describe Rake::Funnel::Integration::TeamCity::NUnitPlugin do
-  let(:env_var) { nil }
-  let(:which) { nil }
-  let(:nunit_exe_contents) { nil }
-
   before {
     allow(ENV).to receive(:[]).with(described_class::ENV_VAR).and_return(env_var)
     allow(Which).to receive(:which).and_return(which)
-    allow(File).to receive(:read).with(which).and_return(nunit_exe_contents)
     allow(Dir).to receive(:glob).and_return([])
     allow(RakeFileUtils).to receive(:mkdir_p)
     allow(Rake).to receive(:rake_output_message)
   }
 
-  def binary_version(*version_parts)
-    version = version_parts.map { |p| p.to_s + "\0" }.join(".\0")
-    "F\0i\0l\0e\0V\0e\0r\0s\0i\0o\0n" + "\0" * 3 + version + "\0" * 3
-  end
+  before {
+    allow(BinaryVersionReader).to receive(:read_from).with(which).and_return(nunit_version)
+  }
 
   describe 'success' do
     let(:env_var) { '/path/to/nunit plugins/nunit' }
     let(:addin_dlls) { [env_var + 'addin.dll'] }
     let(:which) { 'path/to/nunit-console.exe' }
-    let(:nunit_exe_contents) { "binary #{binary_version(1, 2, 3, 4)} binary" }
+    let(:nunit_version) { VersionInfo.new({ file_version: '1.2.3.4' }) }
+    let(:plugin_version) { nunit_version.file_version.split('.').take(3).join('.') }
 
     before {
       allow(Dir).to receive(:glob).and_return(addin_dlls)
@@ -39,7 +34,7 @@ describe Rake::Funnel::Integration::TeamCity::NUnitPlugin do
     end
 
     it 'should enumerate addin files' do
-      expect(Dir).to have_received(:glob).with(/#{Regexp.escape(env_var + '-1.2.3.*')}$/)
+      expect(Dir).to have_received(:glob).with(/#{Regexp.escape("#{env_var}-#{plugin_version}\.*")}$/)
     end
 
     it 'should copy the addin from TeamCity to NUnit' do
@@ -47,7 +42,7 @@ describe Rake::Funnel::Integration::TeamCity::NUnitPlugin do
     end
 
     it 'should report that the addin is installed' do
-      expect(Rake).to have_received(:rake_output_message).with("Installing TeamCity NUnit addin for version 1.2.3 in #{which}")
+      expect(Rake).to have_received(:rake_output_message).with("Installing TeamCity NUnit addin for version #{plugin_version} in #{which}")
     end
 
     context 'Windows-style path in environment variable', platform: :win32 do
@@ -60,6 +55,10 @@ describe Rake::Funnel::Integration::TeamCity::NUnitPlugin do
   end
 
   describe 'failures' do
+    let(:env_var) { nil }
+    let(:which) { nil }
+    let(:nunit_version) { VersionInfo.new }
+
     before {
       described_class.setup('nunit-console.exe')
     }
@@ -67,8 +66,8 @@ describe Rake::Funnel::Integration::TeamCity::NUnitPlugin do
     context 'TeamCity plugin path not in environment' do
       let(:env_var) { nil }
 
-      it 'should skip' do
-        expect(File).to_not have_received(:read)
+      it 'should skip reading the version' do
+        expect(BinaryVersionReader).to_not have_received(:read_from)
       end
     end
 
@@ -76,15 +75,14 @@ describe Rake::Funnel::Integration::TeamCity::NUnitPlugin do
       let(:env_var) { '/path/to/nunit plugins/nunit' }
       let(:which) { nil }
 
-      it 'should skip' do
-        expect(File).to_not have_received(:read)
+      it 'should skip reading the version' do
+        expect(BinaryVersionReader).to_not have_received(:read_from)
       end
     end
 
     context 'NUnit executable without version' do
       let(:env_var) { '/path/to/nunit plugins/nunit' }
       let(:which) { 'path/to/nunit-console.exe' }
-      let(:nunit_exe_contents) { 'version number not available ' }
 
       it 'should report that the version could not be read' do
         expect(Rake).to have_received(:rake_output_message).with("Could read version from NUnit executable in #{which}")
@@ -98,7 +96,7 @@ describe Rake::Funnel::Integration::TeamCity::NUnitPlugin do
     context 'plugin for NUnit version not available' do
       let(:env_var) { '/path/to/nunit plugins/nunit' }
       let(:which) { 'path/to/nunit-console.exe' }
-      let(:nunit_exe_contents) { binary_version(1, 2, 3, 4) }
+      let(:nunit_version) { VersionInfo.new({ file_version: '1.2.3.4' }) }
 
       it 'should report that the addin version is not available' do
         expect(Rake).to have_received(:rake_output_message).with(/Could not find TeamCity NUnit addin for version 1\.2\.3 in .*#{env_var}$/)

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

@@ -0,0 +1,29 @@
+describe Rake::Funnel::Support::BinaryVersionReader do
+  def binary_version(*version_parts)
+    version = version_parts.map { |p| p.to_s + "\0" }.join(".\0")
+    "F\0i\0l\0e\0V\0e\0r\0s\0i\0o\0n" + "\0" * 3 + version + "\0" * 3
+  end
+
+  let(:file) { 'some assembly' }
+
+  before {
+    allow(File).to receive(:binread).with(file).and_return(contents)
+  }
+
+  describe 'version can be read' do
+    let(:version) { %w(1 2 3 4) }
+    let(:contents) { "binary #{binary_version(*version)} binary" }
+
+    it 'should yield all parts' do
+      expect(described_class.read_from(file).file_version).to eq(version.join('.'))
+    end
+  end
+
+  describe 'version cannot be read' do
+    let(:contents) { 'this does not contain a version number' }
+
+    it 'should yield empty VersionInfo' do
+      expect(described_class.read_from(file).to_h).to be_empty
+    end
+  end
+end

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

@@ -0,0 +1,58 @@
+describe Rake::Funnel::Support::Copier do
+  let(:source) { files + directories }
+  let(:files) { %w(bin/1 bin/2 bin/3/4 bin/directory/file) }
+  let(:directories) { %w(bin/directory bin/directory-no-content) }
+  let(:target) { 'target path' }
+
+  context 'failure' do
+    context 'target not defined' do
+      let(:target) { nil }
+
+      it 'should fail' do
+        expect { described_class.copy([], nil) }.to raise_error(/Target not defined/)
+      end
+    end
+  end
+
+  describe 'recursive copy' do
+    before {
+      allow(File).to receive(:directory?).and_return(false)
+      directories.each do |dir|
+        allow(File).to receive(:directory?).with(dir).and_return(true)
+      end
+
+      allow(RakeFileUtils).to receive(:mkdir_p)
+      allow(RakeFileUtils).to receive(:cp)
+    }
+
+    before {
+      described_class.copy(source, target)
+    }
+
+    def no_prefix(file)
+      file.sub(%r|bin/|, '')
+    end
+
+    it 'should create target directories' do
+      expect(RakeFileUtils).to have_received(:mkdir_p).with(File.join(target, '3'))
+      expect(RakeFileUtils).to have_received(:mkdir_p).with(File.join(target, 'directory'))
+    end
+
+    it 'should skip source directories' do
+      directories.each do |dir|
+        expect(RakeFileUtils).not_to have_received(:cp).with(dir, anything)
+      end
+    end
+
+    it 'should copy files with common path removed' do
+      files.each do |file|
+        target_path = File.join(target, no_prefix(file))
+        expect(RakeFileUtils).to have_received(:cp).with(file, target_path, anything)
+      end
+    end
+
+    it 'should preserve metdata' do
+      expect(RakeFileUtils).to have_received(:cp).with(anything, anything, { preserve: true }).exactly(files.length).times
+    end
+  end
+end

data/spec/rake/funnel/support/{side_by_side_specs/remover_spec.rb → specs_remover_spec.rb}

@@ -1,4 +1,4 @@
-describe Rake::Funnel::Support::SideBySideSpecs::Remover do
+describe Rake::Funnel::Support::SpecsRemover do
   describe 'removal' do
     let(:projects) { [] }
     let(:references) { [] }
@@ -66,7 +66,7 @@ describe Rake::Funnel::Support::SideBySideSpecs::Remover do
     let(:temp_dir) { Dir.mktmpdir }
 
     before {
-      FileUtils.cp_r(File.join(File.dirname(__FILE__), 'example/.'), temp_dir)
+      FileUtils.cp_r(File.join(File.dirname(__FILE__), 'specs_remover/.'), temp_dir)
     }
 
     before {

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

@@ -0,0 +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

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

@@ -3,7 +3,6 @@ include Rake::Funnel::Support
 
 describe Rake::Funnel::Tasks::AssemblyVersion do
   before {
-    CLEAN.clear
     Task.clear
   }
 
@@ -13,32 +12,24 @@ describe Rake::Funnel::Tasks::AssemblyVersion do
     its(:source) { should == :FromVersionFiles }
     its(:source_args) { should == {} }
     its(:target_path) { should be_an_instance_of(Proc) }
-
-    describe 'overriding defaults' do
-      subject {
-        described_class.new(:name) do |t|
-          t.language = [:cs, :vb]
-          t.source = []
-          t.source_args = { foo: 42 }
-          t.target_path = 'will not work'
-        end
-      }
-
-      its(:name) { should == :name }
-      its(:language) { should == [:cs, :vb] }
-      its(:source) { should == [] }
-      its(:source_args) { should == { foo: 42 } }
-      its(:target_path) { should == 'will not work' }
-    end
   end
 
   describe 'execution' do
-    let(:writer) { double(AssemblyVersionWriter).as_null_object }
+    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
     }

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

@@ -3,7 +3,6 @@ include Rake
 describe Rake::Funnel::Tasks::BinPath do
   before {
     Task.clear
-    expect(subject).to be
   }
 
   describe 'defaults' do
@@ -12,24 +11,37 @@ describe Rake::Funnel::Tasks::BinPath do
   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 contents')
+      allow(ENV).to receive(:[]).with('PATH').and_return(default_path)
       allow(ENV).to receive(:[]=)
       allow(Rake).to receive(:rake_output_message)
     }
 
     before {
-      subject.search_pattern = %w(foo bar)
+      allow(Dir).to receive(:[]).with(*search_pattern).and_return(search_pattern)
+    }
 
-      allow(Dir).to receive(:[]).with(*subject.search_pattern).and_return(subject.search_pattern)
+    subject {
+      described_class.new do |t|
+        t.search_pattern = search_pattern
+      end
+    }
 
-      Task[:bin_path].invoke
+    before {
+      Task[subject.name].invoke
     }
 
     it 'should prepend sorted matching folders to the PATH environment variable' do
-      paths = subject.search_pattern.sort.map { |path| File.expand_path(path) } << ENV['PATH']
+      paths = search_pattern.map { |path| File.expand_path(path) }.sort.join(File::PATH_SEPARATOR)
+
+      expect(ENV).to have_received(:[]=).with('PATH',/^#{paths}/)
+    end
 
-      expect(ENV).to have_received(:[]=).with('PATH', paths.join(File::PATH_SEPARATOR))
+    it 'should append original PATH environment variable' do
+      expect(ENV).to have_received(:[]=).with('PATH', /#{default_path}$/)
     end
 
     it 'should report added paths' do