rake-funnel 0.18.0 → 0.19.0

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

@@ -15,6 +15,7 @@ module Rake
         end
 
         private
+
         def setup_ivars(args)
           @name = args.shift || :package
 
@@ -24,11 +25,11 @@ module Rake
           @allow_empty = true
         end
 
-        def define(args, &task_block)
+        def define(args, &task_block) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
           desc 'Zip files' 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
+            yield(*[self, task_args].slice(0, task_block.arity)) if task_block
 
             if files.empty? && !allow_empty
               Rake.rake_output_message('No files to zip')

data/lib/rake/funnel/version.rb

@@ -1,5 +1,5 @@
 module Rake
   module Funnel
-    VERSION = '0.18.0'.freeze
+    VERSION = '0.19.0'.freeze
   end
 end

data/rake-funnel.gemspec

@@ -2,33 +2,33 @@ lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'rake/funnel/version'
 
-Gem::Specification.new do |s|
+Gem::Specification.new do |s| # rubocop:disable Metrics/BlockLength
   s.name        = 'rake-funnel'
   s.version     = Rake::Funnel::VERSION
   s.platform    = Gem::Platform::RUBY
   s.authors     = ['Alexander Groß']
   s.email       = ['agross@therightstuff.de']
   s.homepage    = 'http://grossweber.com'
-  s.license     = 'BSD'
+  s.license     = 'BSD-3-Clause'
   s.description = 'A standardized build pipeline'
-  s.summary     = 'A build pipeline targeted at .NET projects. Supports environment configuration and makes invoking .NET-related tasks easier.'
+  s.summary     = 'A build pipeline targeted at .NET projects. Supports environment configuration and makes invoking .NET-related tasks easier.' # rubocop:disable Metrics/LineLength
 
   s.required_ruby_version = '>= 2.0.0'
 
-  s.add_dependency 'rake', '>= 10.4', '< 12'
+  s.add_dependency 'rake', '>= 10.4', '< 13'
   s.add_dependency 'rubyzip', '~> 1.0'
   s.add_dependency 'smart_colored'
   s.add_dependency 'configatron', '~> 4.5'
 
   git = ENV['TEAMCITY_GIT_PATH'] || 'git'
   files = `"#{git}" ls-files -z`
-    .split("\x0")
-    .reject do |file|
-      file =~ %r{^(config/|tools/|lib/tasks)} ||
-        file =~ %r{\.git|\.travis|\.ruby-version|\.rubocop} ||
-        file =~ %r{(Guard|Rake)file} ||
-        File.extname(file) == '.cmd'
-    end
+          .split("\x0")
+          .reject do |file|
+    file =~ %r{^(config/|tools/|lib/tasks)} ||
+      file =~ /\.git|\.travis|\.ruby-version|\.rubocop/ ||
+      file =~ /(Guard|Rake)file/ ||
+      File.extname(file) == '.cmd'
+  end
 
   s.files         = files
   s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }

data/spec/rake/funnel/execution_error_spec.rb

@@ -38,7 +38,7 @@ describe Rake::Funnel::ExecutionError do
         end
 
         context 'longer than 10 lines' do
-          let(:output) {
+          let(:output) do
             output = []
 
             11.times.each do |i|
@@ -46,7 +46,7 @@ describe Rake::Funnel::ExecutionError do
             end
 
             output.join("\n")
-          }
+          end
 
           subject { described_class.new(nil, nil, output) }
 

data/spec/rake/funnel/extensions/rexml_spec.rb

@@ -1,12 +1,15 @@
+# rubocop:disable RSpec/FilePath
+
 describe Rake::Funnel::Extensions::REXML::Functions do
-  let(:xml) { <<EOF
+  let(:xml) do
+    <<EOF
   <editors xmlns="http://example.com">
     <editor id="emacs">EMACS</editor>
     <editor id="vi">VIM</editor>
     <editor id="notepad">Notepad</editor>
   </editors>
 EOF
-  }
+  end
 
   subject { REXML::Document.new(xml) }
 

data/spec/rake/funnel/extensions/shell_spec.rb

@@ -3,13 +3,13 @@ require 'open3'
 include Rake::Funnel
 
 describe Rake::Funnel::Extensions::Shell do
-  before {
+  before do
     allow(Open3).to receive(:popen2e).and_yield(nil, stdout_and_stderr, exit)
 
     allow($stdout).to receive(:puts)
     allow($stderr).to receive(:puts)
     allow(Rake).to receive(:rake_output_message)
-  }
+  end
 
   let(:exit) { OpenStruct.new(value: OpenStruct.new(success?: true, exitstatus: 0)) }
 
@@ -87,10 +87,10 @@ describe Rake::Funnel::Extensions::Shell do
   end
 
   describe 'log file' do
-    before {
+    before do
       allow(subject).to receive(:mkdir_p)
       allow(File).to receive(:open)
-    }
+    end
 
     let(:log_file) { nil }
 
@@ -98,12 +98,12 @@ describe Rake::Funnel::Extensions::Shell do
 
     context 'no log file' do
       it 'should not create path to log file' do
-        expect(subject).to_not have_received(:mkdir_p)
+        expect(subject).not_to have_received(:mkdir_p)
       end
 
       it 'should not write log file' do
-        expect(subject).to_not have_received(:mkdir_p)
-        expect(File).to_not have_received(:open)
+        expect(subject).not_to have_received(:mkdir_p)
+        expect(File).not_to have_received(:open)
       end
     end
 
@@ -123,16 +123,16 @@ describe Rake::Funnel::Extensions::Shell do
   describe 'error detection' do
     let(:error_lines) { /error/ }
 
-    before {
+    before do
       begin
         subject.shell('foo', error_lines: error_lines)
-      rescue ExecutionError
+      rescue ExecutionError # rubocop:disable Lint/HandleExceptions
       end
-    }
+    end
 
     context 'no lines indicating errors' do
       it 'should not log to stderr' do
-        expect($stderr).to_not have_received(:puts)
+        expect($stderr).not_to have_received(:puts)
       end
     end
 
@@ -148,7 +148,7 @@ describe Rake::Funnel::Extensions::Shell do
       end
 
       it 'should not log to stdout on error' do
-        expect($stdout).to_not have_received(:puts).with(/error/)
+        expect($stdout).not_to have_received(:puts).with(/error/)
       end
 
       it 'should colorize error lines' do
@@ -205,7 +205,10 @@ describe Rake::Funnel::Extensions::Shell do
         end
 
         it 'should yield the error' do
-          expect { |b| subject.shell('foo', error_lines: /.*/, &b) }.to yield_with_args(false, 'foo', 0, /output/)
+          expect { |b| subject.shell('foo', error_lines: /.*/, &b) }.to yield_with_args(false,
+                                                                                        'foo',
+                                                                                        0,
+                                                                                        /output/)
         end
       end
     end
@@ -219,15 +222,18 @@ describe Rake::Funnel::Extensions::Shell do
         end
 
         it 'should report the exit code' do
-          expect { subject.shell('foo') }.to raise_error { |e| expect(e.exit_code).to eq(exit.value.exitstatus) }
+          expect { subject.shell('foo') }
+            .to(raise_error { |e| expect(e.exit_code).to eq(exit.value.exitstatus) })
         end
 
         it 'should report the command that was run' do
-          expect { subject.shell('foo') }.to raise_error { |e| expect(e.command).to eq('foo') }
+          expect { subject.shell('foo') }
+            .to(raise_error { |e| expect(e.command).to eq('foo') })
         end
 
         it 'should report logged lines' do
-          expect { subject.shell('foo') }.to raise_error { |e| expect(e.output).to eq(stdout_and_stderr.string) }
+          expect { subject.shell('foo') }
+            .to(raise_error { |e| expect(e.output).to eq(stdout_and_stderr.string) })
         end
       end
 
@@ -237,7 +243,10 @@ describe Rake::Funnel::Extensions::Shell do
         end
 
         it 'should yield the error' do
-          expect { |b| subject.shell('foo', error_lines: /.*/, &b) }.to yield_with_args(false, 'foo', 1, /output/)
+          expect { |b| subject.shell('foo', error_lines: /.*/, &b) }.to yield_with_args(false,
+                                                                                        'foo',
+                                                                                        1,
+                                                                                        /output/)
         end
       end
     end

data/spec/rake/funnel/integration/progress_report_spec.rb

@@ -6,27 +6,27 @@ describe Rake::Funnel::Integration::ProgressReport do
 
   let(:teamcity_running?) { false }
 
-  before {
+  before do
     allow($stdout).to receive(:puts)
     allow(TeamCity).to receive(:running?).and_return(teamcity_running?)
 
     Task.clear
-  }
+  end
 
-  after {
+  after do
     subject.disable!
-  }
+  end
 
   describe 'defaults' do
-    subject! {
+    subject! do
       described_class.new
-    }
+    end
 
-    before {
+    before do
       task :task
 
       Task[:task].invoke
-    }
+    end
 
     context 'not on TeamCity' do
       it 'should write colored task name in square brackets' do
@@ -38,57 +38,53 @@ describe Rake::Funnel::Integration::ProgressReport do
       let(:teamcity_running?) { true }
 
       it 'should not write task name since it would clutter the output' do
-        expect($stdout).to_not have_received(:puts).with(/task/)
+        expect($stdout).not_to have_received(:puts).with(/task/)
       end
     end
   end
 
   context 'when progess report was disabled' do
-    subject {
+    subject do
       described_class.new
-    }
+    end
 
-    before {
+    before do
       subject.disable!
 
       task :task
 
       Task[:task].invoke
-    }
+    end
 
     it 'should not write' do
-      expect($stdout).to_not have_received(:puts).with("\n[task]")
+      expect($stdout).not_to have_received(:puts).with("\n[task]")
     end
   end
 
   describe 'custom event handlers' do
     let(:receiver) { double.as_null_object }
 
-    subject! {
+    subject! do
       described_class.new do |r|
         r.task_starting do |task, args|
-          receiver.task_starting({
-            task: task,
-            args: args
-          })
+          receiver.task_starting(task: task,
+                                 args: args)
         end
 
         r.task_finished do |task, args, error|
-          receiver.task_finished({
-            task: task,
-            args: args,
-            error: error
-          })
+          receiver.task_finished(task: task,
+                                 args: args,
+                                 error: error)
         end
       end
-    }
+    end
 
     context 'when task succeeds' do
-      before {
+      before do
         task :task
 
         Task[:task].invoke
-      }
+      end
 
       describe 'starting handler' do
         it 'should run' do
@@ -96,11 +92,11 @@ describe Rake::Funnel::Integration::ProgressReport do
         end
 
         it 'should receive task' do
-          expect(receiver).to have_received(:task_starting).with(hash_including({ task: kind_of(Task) }))
+          expect(receiver).to have_received(:task_starting).with(hash_including(task: kind_of(Task)))
         end
 
         it 'should receive task arguments' do
-          expect(receiver).to have_received(:task_starting).with(hash_including({ args: kind_of(TaskArguments) }))
+          expect(receiver).to have_received(:task_starting).with(hash_including(args: kind_of(TaskArguments)))
         end
       end
 
@@ -110,15 +106,15 @@ describe Rake::Funnel::Integration::ProgressReport do
         end
 
         it 'should receive task' do
-          expect(receiver).to have_received(:task_finished).with(hash_including({ task: kind_of(Task) }))
+          expect(receiver).to have_received(:task_finished).with(hash_including(task: kind_of(Task)))
         end
 
         it 'should receive task arguments' do
-          expect(receiver).to have_received(:task_finished).with(hash_including({ args: kind_of(TaskArguments) }))
+          expect(receiver).to have_received(:task_finished).with(hash_including(args: kind_of(TaskArguments)))
         end
 
         it 'should not receive error' do
-          expect(receiver).to have_received(:task_finished).with(hash_including({ error: nil }))
+          expect(receiver).to have_received(:task_finished).with(hash_including(error: nil))
         end
       end
     end
@@ -128,20 +124,20 @@ describe Rake::Funnel::Integration::ProgressReport do
 
       let(:error) { SpecificError.new('task error') }
 
-      before {
+      before do
         task :task do
           raise error
         end
 
         begin
           Task[:task].invoke
-        rescue SpecificError
+        rescue SpecificError # rubocop:disable Lint/HandleExceptions
         end
-      }
+      end
 
       describe 'finished handler' do
         it 'should receive error' do
-          expect(receiver).to have_received(:task_finished).with(hash_including({ error: error }))
+          expect(receiver).to have_received(:task_finished).with(hash_including(error: error))
         end
       end
     end

data/spec/rake/funnel/integration/sync_output_spec.rb

@@ -1,30 +1,30 @@
 describe Rake::Funnel::Integration::SyncOutput do
   context 'stream supports sync mode' do
-    before {
+    before do
       allow($stdout).to receive(:sync=)
       allow($stderr).to receive(:sync=)
 
       expect(subject).to be
-    }
+    end
 
     it 'should immediately flush $stdout' do
       expect($stdout).to have_received(:sync=).with(true)
     end
 
     it 'should immediately flush $stderr' do
-      expect($stdout).to have_received(:sync=).with(true)
+      expect($stderr).to have_received(:sync=).with(true)
     end
   end
 
   context 'stream does not support sync mode' do
-    before {
+    before do
       allow($stdout).to receive(:sync=).and_raise('$stdout.sync not supported')
       allow($stderr).to receive(:sync=).and_raise('$stderr.sync not supported')
 
       allow(Rake).to receive(:rake_output_message)
 
       expect(subject).to be
-    }
+    end
 
     it 'should log the error for $stdout' do
       expect(Rake).to have_received(:rake_output_message).with(/Failed.*\$stdout/)

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

@@ -1,33 +1,35 @@
+# rubocop:disable RSpec/FilePath
+
 include Rake::Funnel::Support
 
 describe Rake::Funnel::Integration::TeamCity::NUnitPlugin do
-  before {
+  before do
     allow(ENV).to receive(:[]).with(described_class::ENV_VAR).and_return(env_var)
     allow(Which).to receive(:which).and_return(which)
     allow(Dir).to receive(:glob).and_return([])
     allow(RakeFileUtils).to receive(:mkdir_p)
     allow(Rake).to receive(:rake_output_message)
-  }
+  end
 
-  before {
+  before do
     allow(BinaryVersionReader).to receive(:read_from).with(which).and_return(nunit_version)
-  }
+  end
 
   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_version) { VersionInfo.new({ file_version: '1.2.3.4' }) }
+    let(:nunit_version) { VersionInfo.new(file_version: '1.2.3.4') }
     let(:plugin_version) { nunit_version.file_version.split('.').take(3).join('.') }
 
-    before {
+    before do
       allow(Dir).to receive(:glob).and_return(addin_dlls)
       allow(RakeFileUtils).to receive(:cp)
-    }
+    end
 
-    before {
+    before do
       described_class.setup('nunit-console.exe')
-    }
+    end
 
     it 'should create addin directory' do
       expect(RakeFileUtils).to have_received(:mkdir_p).with(File.join(File.dirname(which), 'addins'))
@@ -38,18 +40,24 @@ describe Rake::Funnel::Integration::TeamCity::NUnitPlugin do
     end
 
     it 'should copy the addin from TeamCity to NUnit' do
-      expect(RakeFileUtils).to have_received(:cp).with(addin_dlls, File.join(File.dirname(which), 'addins'), preserve: true)
+      expect(RakeFileUtils).to \
+        have_received(:cp).with(addin_dlls,
+                                File.join(File.dirname(which), 'addins'),
+                                preserve: true)
     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 #{plugin_version} 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
+    context 'Windows-style path in environment variable',
+            skip: ('Windows Registry not available' unless defined?(::Win32::Registry)) do
       let(:env_var) { 'C:\path\to\nunit plugins\nunit-' }
 
       it 'should convert path to Ruby-style' do
-        expect(Dir).to have_received(:glob).with(%r|^C:/path/to/nunit plugins/nunit-|)
+        expect(Dir).to have_received(:glob).with(%r{^C:/path/to/nunit plugins/nunit-})
       end
     end
   end
@@ -59,15 +67,15 @@ describe Rake::Funnel::Integration::TeamCity::NUnitPlugin do
     let(:which) { nil }
     let(:nunit_version) { VersionInfo.new }
 
-    before {
+    before do
       described_class.setup('nunit-console.exe')
-    }
+    end
 
     context 'TeamCity plugin path not in environment' do
       let(:env_var) { nil }
 
       it 'should skip reading the version' do
-        expect(BinaryVersionReader).to_not have_received(:read_from)
+        expect(BinaryVersionReader).not_to have_received(:read_from)
       end
     end
 
@@ -76,7 +84,7 @@ describe Rake::Funnel::Integration::TeamCity::NUnitPlugin do
       let(:which) { nil }
 
       it 'should skip reading the version' do
-        expect(BinaryVersionReader).to_not have_received(:read_from)
+        expect(BinaryVersionReader).not_to have_received(:read_from)
       end
     end
 
@@ -85,7 +93,9 @@ describe Rake::Funnel::Integration::TeamCity::NUnitPlugin do
       let(:which) { 'path/to/nunit-console.exe' }
 
       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}")
+        expect(Rake).to \
+          have_received(:rake_output_message)
+          .with("Could read version from NUnit executable in #{which}")
       end
 
       it 'should skip' do
@@ -96,10 +106,12 @@ 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_version) { VersionInfo.new({ file_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}$/)
+        expect(Rake).to \
+          have_received(:rake_output_message)
+          .with(/Could not find TeamCity NUnit addin for version 1\.2\.3 in .*#{env_var}$/)
       end
 
       it 'should skip' do