rake-funnel 0.0.1.pre

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

@@ -0,0 +1,108 @@
+describe Rake::Funnel::Support::Patch do
+  describe 'without definition' do
+    it 'should be applicable' do
+      subject.apply!
+    end
+
+    it 'should be revertable' do
+      subject.revert!
+    end
+
+    it 'should be applicable and revertable' do
+      subject.apply!.revert!
+    end
+  end
+
+  describe 'with definition' do
+    subject {
+      described_class.new do |p|
+        p.setup do
+          output.puts 'setup'
+          42
+        end
+
+        p.reset do |memo|
+          output.puts memo
+        end
+      end
+    }
+
+    let(:output) { double.as_null_object }
+
+    context 'when applying the patch' do
+      let!(:ret) { subject.apply! }
+
+      it 'should execute the setup' do
+        expect(output).to have_received(:puts).with('setup')
+      end
+
+      it 'should return self' do
+        expect(ret).to eq(subject)
+      end
+    end
+
+    context 'when reverting the patch' do
+      let!(:ret) {
+        subject.apply!
+        subject.revert!
+      }
+
+      it 'should execute the reset' do
+        expect(output).to have_received(:puts).with(42)
+      end
+
+      it 'should return self' do
+        expect(ret).to eq(subject)
+      end
+    end
+
+    context 'when reverting an unapplied patch' do
+      before { subject.revert! }
+
+      it 'should not execute the reset' do
+        expect(output).to_not have_received(:puts).with(42)
+      end
+    end
+
+    context 'when applying twice' do
+      before {
+        subject.apply!
+        subject.apply!
+      }
+
+      it 'should execute the setup once' do
+        expect(output).to have_received(:puts).with('setup').once
+      end
+    end
+
+    context 'when reverting twice' do
+      before {
+        subject.apply!
+        subject.revert!
+        subject.revert!
+      }
+
+      it 'should execute the revert once' do
+        expect(output).to have_received(:puts).with(42).once
+      end
+    end
+
+    describe 'context' do
+      let(:context) { 42 }
+
+      subject {
+        described_class.new(context) do |p|
+          p.setup do |context|
+            output.puts context
+          end
+        end
+      }
+
+      before { subject.apply!.revert! }
+
+      it 'should be accessible from within the patch definition' do
+        expect(output).to have_received(:puts).with(42)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+describe Rake::Funnel::Support::TemplateEngine do
+  it 'should render nil' do
+    expect(described_class.render(nil)).to eq('')
+  end
+
+  it 'should render empty string' do
+    expect(described_class.render('')).to eq('')
+  end
+
+  it 'should static string' do
+    expect(described_class.render('hello world')).to eq('hello world')
+  end
+
+  it 'should support ruby' do
+    expect(described_class.render('<%= 42 %>')).to eq('42')
+  end
+
+  it 'should omit newlines for pure ruby lines' do
+    template = <<-EOF
+<%= 42 %>
+    EOF
+
+    expect(described_class.render(template)).to eq('42')
+  end
+
+  it 'should not omit newlines for mixed ruby lines' do
+    template = <<-EOF
+12 <%= 34 %> 56
+    EOF
+
+    expect(described_class.render(template)).to eq("12 34 56\n")
+  end
+
+  it 'should support @ instead of <%= %>' do
+    expect(described_class.render('@String.to_s@')).to eq('String')
+  end
+
+  describe 'binding' do
+    context 'without binding' do
+      it 'should not support contextual variables' do
+        var = 42
+        template = '<%= var %>'
+
+        expect(lambda { described_class.render(template) }).to raise_error
+      end
+    end
+
+    context 'with binding' do
+      def get_binding(value)
+        binding
+      end
+
+      it 'should support contextual variables with binding' do
+        template = '<%= value %>'
+
+        expect(described_class.render(template, nil, get_binding(42))).to eq('42')
+      end
+    end
+  end
+
+  it 'should report errors with file name' do
+    expect(lambda { described_class.render('<%= undefined %>', 'file.template') })
+      .to raise_error { |ex| expect(ex.backtrace.join("\n")).to match(/file\.template/) }
+  end
+end

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

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

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

@@ -0,0 +1,40 @@
+include Rake
+
+describe Rake::Funnel::Tasks::BinPath do
+  before {
+    Task.clear
+    expect(subject).to be
+  }
+
+  describe 'defaults' do
+    its(:name) { should == :bin_path }
+    its(:pattern) { is_expected.to match_array(%w(tools/* tools/*/bin packages/**/tools)) }
+  end
+
+  describe 'execution' do
+    before {
+      allow(ENV).to receive(:[]).with('PATH').and_return('default PATH contents')
+      allow(ENV).to receive(:[]=)
+      allow(Rake).to receive(:rake_output_message)
+    }
+
+    before {
+      subject.pattern = %w(foo bar)
+
+      allow(Dir).to receive(:[]).with(*subject.pattern).and_return(subject.pattern)
+
+      Task[:bin_path].invoke
+    }
+
+    it 'should prepend sorted matching folders to the PATH environment variable' do
+      paths = subject.pattern.sort.map { |path| File.expand_path(path) } << ENV['PATH']
+
+      expect(ENV).to have_received(:[]=).with('PATH', paths.join(File::PATH_SEPARATOR))
+    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

@@ -0,0 +1,101 @@
+require 'tmpdir'
+
+include Rake
+include Rake::Funnel::Support
+
+describe Rake::Funnel::Tasks::Copy do
+  before {
+    CLEAN.clear
+    Task.clear
+  }
+
+  describe 'defaults' do
+    its(:name) { should == :copy }
+    its(:source) { should eq([]) }
+    its(:target) { should be_nil }
+
+    it 'should not add the target file to the files to be cleaned' do
+      expect(CLEAN).to be_empty
+    end
+
+    describe 'overriding defaults' do
+      subject {
+        described_class.new do |t|
+          t.target = 'something'
+        end
+      }
+
+      it 'should add the target file to the files to be cleaned' do
+        expect(CLEAN).to include(subject.target)
+      end
+    end
+  end
+
+  describe 'execution' do
+    let(:source) { %w(bin/1 bin/2 bin/3/4 bin/directory/file bin/directory bin/directory-no-content) }
+    let(:target) { 'some path' }
+
+    subject! {
+      described_class.new do |t|
+        t.source = source
+        t.target = target
+      end
+    }
+
+    context 'failure' do
+      context 'target not defined' do
+        let(:target) { nil }
+
+        it 'should fail' do
+          expect(lambda { Task[subject.name].invoke }).to raise_error(/Target not defined/)
+        end
+      end
+    end
+
+    context 'success' do
+      let(:finder) { double(Finder).as_null_object }
+
+      before {
+        allow(finder).to receive(:all_or_default).and_return(source)
+        allow(Finder).to receive(:new).and_return(finder)
+
+        allow(File).to receive(:directory?).and_return(false)
+        source.last(2).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 {
+        Task[subject.name].invoke
+      }
+
+      def no_prefix(file)
+        file.sub(%r|bin/|, '')
+      end
+
+      it 'should create target directories' do
+        expect(RakeFileUtils).to have_received(:mkdir_p).with(subject.target + '/3')
+        expect(RakeFileUtils).to have_received(:mkdir_p).with(subject.target + '/directory')
+      end
+
+      it 'should skip source directories' do
+        source
+          .select { |src| File.directory?(src) }
+          .each do |src|
+          expect(RakeFileUtils).not_to have_received(:cp).with(src, anything)
+        end
+      end
+
+      it 'should copy files with common path removed' do
+        source
+          .select { |src| !File.directory?(src) }
+          .each do |src|
+          expect(RakeFileUtils).to have_received(:cp).with(src, File.join(subject.target, no_prefix(src)))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,237 @@
+include Rake
+include Rake::Funnel::Support
+include Rake::Funnel::Tasks
+
+describe Rake::Funnel::Tasks::Environments do
+  include Rake::DSL
+
+  before {
+    Task.clear
+  }
+
+  let(:files) { [] }
+
+  before {
+    allow(Dir).to receive(:[]).and_return(files)
+  }
+
+  def disable_default_env_setup
+    allow_any_instance_of(described_class).to receive(:default_environment_setup)
+  end
+
+  describe 'defaults' do
+    before {
+      disable_default_env_setup
+    }
+
+    its(:base_dir) { should == 'config' }
+    its(:default_env) { should be_nil }
+    its(:default_config) { should == 'default' }
+    its(:local_config) { should == 'local' }
+
+    describe 'overriding defaults' do
+      subject {
+        described_class.new do |t|
+          t.base_dir = 'custom base_dir'
+          t.default_env = 'custom default_env'
+          t.default_config = 'custom default_config'
+          t.local_config = 'custom local_config'
+        end
+      }
+
+      its(:base_dir) { should == subject.base_dir }
+      its(:default_env) { should == subject.default_env }
+      its(:default_config) { should == subject.default_config }
+      its(:local_config) { should == subject.local_config }
+    end
+  end
+
+  describe 'definition' do
+    before {
+      disable_default_env_setup
+    }
+
+    before {
+      allow_any_instance_of(described_class).to receive(:task)
+    }
+
+    let(:files) {
+      %w(config/default.yaml config/local.yaml config/dev.yaml config/production.yaml)
+    }
+
+    it 'should define a task for each config file' do
+      expect(subject).to have_received(:task).with('dev')
+      expect(subject).to have_received(:task).with('production')
+    end
+
+    it 'should omit environment for the default config file' do
+      expect(subject).not_to have_received(:task).with('default')
+    end
+
+    it 'should omit environment for the local config file' do
+      expect(subject).not_to have_received(:task).with('local')
+    end
+  end
+
+  describe 'config files to load' do
+    let(:files) {
+      %w(config/dev.yaml)
+    }
+
+    before {
+      allow(EnvironmentsSupport::Loader).to receive(:load_configuration)
+    }
+
+    before {
+      allow(File).to receive(:exists?).and_return(true)
+      allow(File).to receive(:exists?).with(optional).and_return(false)
+    }
+
+    subject {
+      described_class.new do |t|
+        t.default_env = 'dev'
+      end
+    }
+
+    before {
+      expect(subject).to be
+    }
+
+    context 'default and local config files exist' do
+      let(:optional) { nil }
+
+      it 'should load all files' do
+        expect(EnvironmentsSupport::Loader)
+          .to have_received(:load_configuration).with(hash_including({ config_files: %w(config/default.yaml config/dev.yaml config/local.yaml) }))
+      end
+    end
+
+    context 'default config file does not exist' do
+      let(:optional) { 'config/default.yaml' }
+
+      it 'should load environment file and local file' do
+        expect(EnvironmentsSupport::Loader)
+          .to have_received(:load_configuration).with(hash_including({ config_files: %w(config/dev.yaml config/local.yaml) }))
+      end
+    end
+
+    context 'local config file does not exist' do
+      let(:optional) { 'config/local.yaml' }
+
+      it 'should load default file and environment file' do
+        expect(EnvironmentsSupport::Loader)
+          .to have_received(:load_configuration).with(hash_including({ config_files: %w(config/default.yaml config/dev.yaml) }))
+      end
+    end
+  end
+
+  describe 'automatic environment setup' do
+    let(:files) {
+      %w(config/dev.yaml config/production.yaml)
+    }
+
+    before {
+      allow(EnvironmentsSupport::Loader).to receive(:load_configuration)
+    }
+
+    context 'no default environment configured' do
+      before {
+        expect(subject).to be
+      }
+
+      it 'should not invoke environment tasks' do
+        expect(EnvironmentsSupport::Loader).not_to have_received(:load_configuration)
+      end
+    end
+
+    context 'default environment configured' do
+      subject {
+        described_class.new do |t|
+          t.default_env = 'dev'
+        end
+      }
+
+      before {
+        allow(Rake.application).to receive(:top_level_tasks).and_return(user_defined_task)
+      }
+
+      before {
+        expect(subject).to be
+      }
+
+      context 'no user-defined environment' do
+        let(:user_defined_task) { %w(foo) }
+
+        it 'should invoke default environment task' do
+          expect(EnvironmentsSupport::Loader)
+            .to have_received(:load_configuration).with(hash_including({ name: 'dev' }))
+        end
+
+        it 'should not invoke other environment tasks' do
+          expect(EnvironmentsSupport::Loader)
+            .not_to have_received(:load_configuration).with(hash_including({ name: 'production' }))
+        end
+      end
+
+      context 'user-defined environment' do
+        let(:user_defined_task) { %w(foo production) }
+
+        it 'should invoke user-defined environment task' do
+          expect(EnvironmentsSupport::Loader)
+            .to have_received(:load_configuration).with(hash_including({ name: 'production' }))
+        end
+
+        it 'should not invoke other environment tasks' do
+          expect(EnvironmentsSupport::Loader)
+            .not_to have_received(:load_configuration).with(hash_including({ name: 'dev' }))
+        end
+      end
+
+      context 'environment task defined in Rake namespace' do
+        subject {
+          namespace :foo do
+            namespace :bar do
+              described_class.new do |t|
+                t.default_env = 'dev'
+              end
+            end
+          end
+        }
+
+        context 'default environment configured' do
+          before {
+            expect(subject).to be
+          }
+
+          context 'no user-defined environment' do
+            let(:user_defined_task) { %w(foo) }
+
+            it 'should invoke default environment task' do
+              expect(EnvironmentsSupport::Loader)
+                .to have_received(:load_configuration).with(hash_including({ name: 'dev' }))
+            end
+
+            it 'should not invoke other environment tasks' do
+              expect(EnvironmentsSupport::Loader)
+                .not_to have_received(:load_configuration).with(hash_including({ name: 'production' }))
+            end
+          end
+
+          context 'user-defined environment' do
+            let(:user_defined_task) { %w(foo foo:bar:production) }
+
+            it 'should invoke user-defined environment task' do
+              expect(EnvironmentsSupport::Loader)
+                .to have_received(:load_configuration).with(hash_including({ name: 'production' }))
+            end
+
+            it 'should not invoke other environment tasks' do
+              expect(EnvironmentsSupport::Loader)
+                .not_to have_received(:load_configuration).with(hash_including({ name: 'dev' }))
+            end
+          end
+        end
+      end
+    end
+  end
+end