rake-funnel 0.0.1.pre

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

@@ -0,0 +1,66 @@
+require 'pathname'
+require 'rake/tasklib'
+require 'zip'
+
+module Rake::Funnel::Tasks
+  class Zip < Rake::TaskLib
+    attr_accessor :name, :source, :target, :zip_root
+
+    def initialize(name = :package)
+      @name = name
+
+      @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
+
+        RakeFileUtils.mkdir_p(File.dirname(target))
+
+        configure_zip
+        create_zip(files, target)
+
+        Rake.rake_output_message("Created #{target}")
+      end
+
+      self
+    end
+
+    def files
+      Rake::Funnel::Support::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)
+
+          zip.add(zipped_file, file)
+        end
+      end
+    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

@@ -0,0 +1,5 @@
+module Rake
+  module Funnel
+    VERSION = '0.0.1.pre'
+  end
+end

data/lib/rake/funnel.rb

@@ -0,0 +1,7 @@
+require 'rake'
+
+module Rake
+  module Funnel; end
+end
+
+require "#{File.dirname(__FILE__)}/funnel/framework.rb"

data/rake-funnel.gemspec

@@ -0,0 +1,28 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rake/funnel/version'
+
+Gem::Specification.new do |s|
+  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.description = %q{A standardized build pipeline}
+  s.summary     = %q{The build pipeline}
+
+  s.required_ruby_version = '>= 2.0.0'
+
+  s.add_dependency 'rake'
+  s.add_dependency 'rubyzip', '~> 1.0'
+  s.add_dependency 'smart_colored'
+  s.add_dependency 'configatron', '~> 4.5'
+
+  git = ENV['TEAMCITY_GIT_PATH'] || 'git'
+  s.files         = `"#{git}" ls-files -z`.split("\x0")
+  s.executables   = s.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ['lib']
+end

data/spec/rake/funnel/execution_error_spec.rb

@@ -0,0 +1,67 @@
+describe Rake::Funnel::ExecutionError do
+  its(:to_s) { should == described_class.to_s }
+
+  context 'with command' do
+    subject { described_class.new('command') }
+
+    its(:command) { should == 'command' }
+    its(:exit_code) { should be_nil }
+    its(:output) { should be_nil }
+    its(:description) { should be_nil }
+    its(:to_s) { should =~ /^Error executing:\scommand/ }
+  end
+
+  context 'with command and exit code' do
+    subject { described_class.new('command', 127) }
+
+    its(:command) { should == 'command' }
+    its(:exit_code) { should == 127 }
+    its(:output) { should be_nil }
+    its(:description) { should be_nil }
+    its(:to_s) { should =~ /^Error executing:\scommand/ }
+    its(:to_s) { should =~ /^Exit code: 127/ }
+    end
+
+  context 'with command and exit code and output' do
+    subject { described_class.new('command', 127, 'output') }
+
+    its(:command) { should == 'command' }
+    its(:exit_code) { should == 127 }
+    its(:output) { should == 'output' }
+    its(:description) { should be_nil }
+    its(:to_s) { should =~ /^Error executing:\scommand/ }
+    its(:to_s) { should =~ /^Exit code: 127/ }
+    its(:to_s) { should =~ /^Command output \(last 10 lines\):\soutput/ }
+  end
+
+  context 'with command and exit code and output and message' do
+    subject { described_class.new('command', 127, 'output', 'description') }
+
+    its(:command) { should == 'command' }
+    its(:exit_code) { should == 127 }
+    its(:output) { should == 'output' }
+    its(:description) { should == 'description' }
+    its(:to_s) { should =~ /^description/ }
+    its(:to_s) { should =~ /^Error executing:\scommand/ }
+    its(:to_s) { should =~ /^Exit code: 127/ }
+    its(:to_s) { should =~ /^Command output \(last 10 lines\):\soutput/ }
+  end
+
+  context 'with output longer than 10 lines' do
+    let(:output) {
+      output = []
+
+      11.times.each do |i|
+        output << "output #{i}"
+      end
+
+      output.join("\n")
+    }
+
+    subject { described_class.new(nil, nil, output) }
+
+    it 'should display the last 10 lines of output' do
+      expect(subject.to_s).not_to match(/^output 0/)
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+describe Rake::Funnel::Extensions::CamelCase do
+  it 'should not touch values without underscores' do
+    expect('foo'.camelize).to eq('foo')
+  end
+
+  it 'should convert strings with underscores' do
+    expect('foo_bar'.camelize).to eq('fooBar')
+  end
+
+  it 'should convert symbols to string' do
+    expect(:foo.camelize).to eq('foo')
+  end
+
+  it 'should convert symbols with underscores' do
+    expect(:foo_bar.camelize).to eq('fooBar')
+  end
+end

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

@@ -0,0 +1,56 @@
+describe Rake::Funnel::Extensions::CommonPath do
+  describe 'Manual debugging test case' do
+    it 'should work' do
+      expect(%w(/common/one /com/two).common_path).to be
+
+      skip('for manual testing only')
+    end
+  end
+
+  describe 'modification of FileList' do
+    it 'should not modify the input' do
+      input = FileList[File.join(File.dirname(__FILE__), '**/*')]
+      duped = input.dup
+
+      expect(input.common_path).to be
+      expect(input).to match_array(duped)
+    end
+  end
+
+  {
+    array: [
+      { input: [], expected: '' },
+      { input: %w(one two), expected: '' },
+      { input: %w(1-common 2-common), expected: '' },
+      { input: %w(common.1 common-2), expected: '' },
+      { input: %w(common-1 common-2), expected: '' },
+      { input: %w(/common common), expected: '' },
+      { input: %w(/ /foo), expected: '/' },
+      { input: %w(/common/one /com/two), expected: '/' },
+      { input: %w(/common/1 /common/2), expected: '/common' },
+      { input: %w(/common/1 /common/2 /common/3/4), expected: '/common' },
+      { input: %w(/common /common), expected: '/common' },
+      { input: %w(/common /common/), expected: '/common' },
+      { input: %w(/common/ /common/), expected: '/common' },
+      { input: ['common/ 1', 'common/ 2'], expected: 'common' },
+      { input: ['com mon/1', 'com mon/2'], expected: 'com mon' },
+      { input: [' common/1', ' common/2'], expected: ' common' },
+      { input: ['common /1', 'common /2'], expected: 'common ' },
+      { input: [''], expected: '' },
+      { input: ['', nil], expected: '' }
+    ],
+    file_list: [
+      { input: FileList.new, expected: '' },
+      { input: FileList['lib/*', 'spec/*'], expected: '' },
+      { input: FileList['spec/*'], expected: 'spec' }
+    ]
+  }.each do |group, pairs|
+    describe group do
+      pairs.each do |pair|
+        it "#{pair[:input]} should equal '#{pair[:expected]}'" do
+          expect(pair[:input].common_path).to eq(pair[:expected])
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+describe Rake::Funnel::Extensions::DisableColors do
+  context 'when connected to a terminal' do
+    before { allow($stdout).to receive(:tty?).and_return(true) }
+
+    it 'should color strings' do
+      expect('foo'.colored.green).to eq("\e[32mfoo\e[0m")
+    end
+
+    it 'should color strings with extension' do
+      expect('foo'.green).to eq("\e[32mfoo\e[0m")
+    end
+
+    it 'should support combinators' do
+      expect('foo'.green.inverse.bold).to eq("\e[1;7;32mfoo\e[0m")
+    end
+  end
+
+  context 'when not connected to a terminal' do
+    before { allow($stdout).to receive(:tty?).and_return(false) }
+
+    it 'should not color strings' do
+      expect('foo'.colored.green).to eq('foo')
+    end
+
+    it 'should not color strings with extension' do
+      expect('foo'.green).to eq('foo')
+    end
+
+    it 'should support combinators' do
+      expect('foo'.green.inverse.bold).to eq('foo')
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+describe Rake::Funnel::Extensions::REXML::Functions do
+  let(:xml) { <<EOF
+  <editors xmlns="http://example.com">
+    <editor id="emacs">EMACS</editor>
+    <editor id="vi">VIM</editor>
+    <editor id="notepad">Notepad</editor>
+  </editors>
+EOF
+  }
+
+  subject { REXML::Document.new(xml) }
+
+  it 'should support lower-case function' do
+    expect(REXML::XPath.match(subject, "//editor[lower-case(text())='vim']").first.to_s).to match(/VIM/)
+  end
+
+  it 'should support matches function' do
+    expect(REXML::XPath.match(subject, "//editor[matches(@id, '*pad')]").first.to_s).to match(/Notepad/)
+  end
+end

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

@@ -0,0 +1,237 @@
+require 'open3'
+
+include Rake::Funnel
+
+describe Rake::Funnel::Extensions::Shell do
+  before {
+    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)
+  }
+
+  let(:exit) { OpenStruct.new(value: OpenStruct.new(success?: true, exitstatus: 0)) }
+
+  let(:stdout_and_stderr) { StringIO.new("output 1\noutput 2\n") }
+
+  subject { Object.new.extend(described_class) }
+
+  after { stdout_and_stderr.close }
+
+  describe 'command' do
+    it 'should accept simple commands' do
+      arg = 'simple'
+
+      subject.shell(arg)
+
+      expect(Open3).to have_received(:popen2e).with(arg)
+    end
+
+    it 'should accept commands with arguments as array' do
+      args = %w(simple 1 2)
+
+      subject.shell(args)
+
+      expect(Open3).to have_received(:popen2e).with(*args)
+    end
+
+    it 'should accept commands with arguments' do
+      subject.shell('1', 2)
+
+      expect(Open3).to have_received(:popen2e).with('1', 2)
+    end
+
+    it 'should reject nil' do
+      subject.shell(1, nil)
+
+      expect(Open3).to have_received(:popen2e).with(1)
+    end
+
+    it 'should accept nested arrays' do
+      subject.shell([1, 2, [3]])
+
+      expect(Open3).to have_received(:popen2e).with(1, 2, 3)
+    end
+
+    it 'should reject nested nils' do
+      subject.shell([1, nil, [3]])
+
+      expect(Open3).to have_received(:popen2e).with(1, 3)
+    end
+
+    it 'should echo the command' do
+      arg = '1', 2
+
+      subject.shell(arg)
+
+      expect(Rake).to have_received(:rake_output_message).with(arg.join(' '))
+    end
+  end
+
+  it 'should return nil' do
+    expect(subject.shell('foo')).to be_nil
+  end
+
+  describe 'output redirection' do
+    before { subject.shell('foo') }
+
+    it 'should redirect command output to stdout' do
+      expect($stdout).to have_received(:puts).with(/output 1/)
+      expect($stdout).to have_received(:puts).with(/output 2/)
+    end
+
+    it 'should colorize lines' do
+      expect($stdout).to have_received(:puts).with('output 1'.green)
+    end
+  end
+
+  describe 'log file' do
+    before {
+      allow(subject).to receive(:mkdir_p)
+      allow(File).to receive(:open)
+    }
+
+    let(:log_file) { nil }
+
+    before { subject.shell('foo', log_file: log_file) }
+
+    context 'no log file' do
+      it 'should not create path to log file' do
+        expect(subject).to_not 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)
+      end
+    end
+
+    context 'with log file' do
+      let(:log_file) { 'tmp/log.txt' }
+
+      it 'should create path to log file' do
+        expect(subject).to have_received(:mkdir_p).with(File.dirname(log_file))
+      end
+
+      it 'should append to log file' do
+        expect(File).to have_received(:open).with(log_file, 'a').at_least(:once)
+      end
+    end
+  end
+
+  describe 'error detection' do
+    let(:error_lines) { /error/ }
+
+    before {
+      begin
+        subject.shell('foo', error_lines: error_lines)
+      rescue ExecutionError
+      end
+    }
+
+    context 'no lines indicating errors' do
+      it 'should not log to stderr' do
+        expect($stderr).to_not have_received(:puts)
+      end
+    end
+
+    context 'lines indicating errors' do
+      let(:stdout_and_stderr) { StringIO.new("output 1\nerror\noutput 2\n") }
+
+      it 'should log to stdout before error' do
+        expect($stdout).to have_received(:puts).with(/output 1/)
+      end
+
+      it 'should log to stderr on error' do
+        expect($stderr).to have_received(:puts).with(/error/)
+      end
+
+      it 'should not log to stdout on error' do
+        expect($stdout).to_not have_received(:puts).with(/error/)
+      end
+
+      it 'should colorize error lines' do
+        expect($stderr).to have_received(:puts).with('error'.bold.red)
+      end
+
+      it 'should log to stdout after error' do
+        expect($stdout).to have_received(:puts).with(/output 2/)
+      end
+    end
+  end
+
+  describe 'callback block' do
+    it 'should yield' do
+      expect { |b| subject.shell('foo', &b) }.to yield_control
+    end
+
+    it 'should yield the success status' do
+      expect { |b| subject.shell('foo', &b) }.to yield_with_args(true, be, be, be)
+    end
+
+    it 'should yield the command' do
+      expect { |b| subject.shell('foo', &b) }.to yield_with_args(be, 'foo', be, be)
+    end
+
+    it 'should yield the exit code' do
+      expect { |b| subject.shell('foo', &b) }.to yield_with_args(be, be, 0, be)
+    end
+
+    it 'should yield the log' do
+      expect { |b| subject.shell('foo', &b) }.to yield_with_args(be, be, be, /output/)
+    end
+  end
+
+  describe 'failure' do
+    context 'error lines logged' do
+      context 'without block' do
+        it 'should fail' do
+          expect { subject.shell('foo', error_lines: /.*/) }.to raise_error(ExecutionError)
+        end
+      end
+
+      context 'with block' do
+        it 'should not fail' do
+          expect { subject.shell('foo', error_lines: /.*/) {} }.not_to raise_error
+        end
+
+        it 'should yield the error' do
+          expect { |b| subject.shell('foo', error_lines: /.*/, &b) }.to yield_with_args(false, 'foo', 0, /output/)
+        end
+      end
+    end
+
+    context 'error exit' do
+      let(:exit) { OpenStruct.new(value: OpenStruct.new(success?: false, exitstatus: 1)) }
+
+      context 'without block' do
+        it 'should fail' do
+          expect { subject.shell('foo') }.to raise_error(ExecutionError)
+        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) }
+        end
+
+        it 'should report the command that was run' do
+          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) }
+        end
+      end
+
+      context 'with block' do
+        it 'should not fail' do
+          expect { subject.shell('foo') {} }.not_to raise_error
+        end
+
+        it 'should yield the error' do
+          expect { |b| subject.shell('foo', error_lines: /.*/, &b) }.to yield_with_args(false, 'foo', 1, /output/)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,149 @@
+include Rake
+include Rake::Funnel::Integration
+
+describe Rake::Funnel::Integration::ProgressReport do
+  include DSL
+
+  let(:teamcity_running?) { false }
+
+  before {
+    allow($stdout).to receive(:puts)
+    allow(TeamCity).to receive(:running?).and_return(teamcity_running?)
+
+    Task.clear
+  }
+
+  after {
+    subject.disable!
+  }
+
+  describe 'defaults' do
+    subject! {
+      described_class.new
+    }
+
+    before {
+      task :task
+
+      Task[:task].invoke
+    }
+
+    context 'not on TeamCity' do
+      it 'should write task name in square brackets' do
+        expect($stdout).to have_received(:puts).with("\n[task]")
+      end
+    end
+
+    context 'on TeamCity' do
+      let(:teamcity_running?) { true }
+
+      it 'should not write task name in square brackets since it would clutter the output' do
+        expect($stdout).to_not have_received(:puts).with("\n[task]")
+      end
+    end
+  end
+
+  context 'when progess report was disabled' do
+    subject! {
+      described_class.new
+    }
+
+    before {
+      subject.disable!
+
+      task :task
+
+      Task[:task].invoke
+    }
+
+    it 'should not write' do
+      expect($stdout).to_not have_received(:puts).with("\n[task]")
+    end
+  end
+
+  describe 'custom event handlers' do
+    let(:receiver) { double.as_null_object }
+
+    subject! {
+      described_class.new do |r|
+        r.task_starting do |task, args|
+          receiver.starting({
+            task: task,
+            args: args
+          })
+        end
+
+        r.task_finished do |task, args, error|
+          receiver.finished({
+            task: task,
+            args: args,
+            error: error
+          })
+        end
+      end
+    }
+
+    context 'when task succeeds' do
+      before {
+        task :task
+
+        Task[:task].invoke
+      }
+
+      describe 'starting handler' do
+        it 'should run' do
+          expect(receiver).to have_received(:starting)
+        end
+
+        it 'should receive task' do
+          expect(receiver).to have_received(:starting).with(hash_including({ task: kind_of(Task) }))
+        end
+
+        it 'should receive task arguments' do
+          expect(receiver).to have_received(:starting).with(hash_including({ args: kind_of(TaskArguments) }))
+        end
+      end
+
+      describe 'finished handler' do
+        it 'should run' do
+          expect(receiver).to have_received(:finished)
+        end
+
+        it 'should receive task' do
+          expect(receiver).to have_received(:finished).with(hash_including({ task: kind_of(Task) }))
+        end
+
+        it 'should receive task arguments' do
+          expect(receiver).to have_received(:finished).with(hash_including({ args: kind_of(TaskArguments) }))
+        end
+
+        it 'should not receive error' do
+          expect(receiver).to have_received(:finished).with(hash_including({ error: nil }))
+        end
+      end
+    end
+
+    context 'when task fails' do
+      class SpecificError < StandardError;  end
+
+      let(:error) { SpecificError.new('task error') }
+
+      before {
+        task :task do
+          raise error
+        end
+
+        begin
+          Task[:task].invoke
+        rescue SpecificError
+        end
+      }
+
+      describe 'finished handler' do
+        it 'should receive error' do
+          expect(receiver).to have_received(:finished).with(hash_including({ error: error }))
+        end
+      end
+    end
+  end
+end