rake-funnel 0.3.2.pre → 0.4.0.pre

data/spec/rake/funnel/execution_error_spec.rb

@@ -1,67 +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
+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/case/camel_case_spec.rb

@@ -1,17 +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
+describe Rake::Funnel::Extensions::Case::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/case/pascal_case_spec.rb

@@ -1,17 +1,17 @@
-describe Rake::Funnel::Extensions::PascalCase do
-  it 'should convert strings' do
-    expect('foo'.pascalize).to eq('Foo')
-  end
-
-  it 'should convert strings with underscores' do
-    expect('foo_bar'.pascalize).to eq('FooBar')
-  end
-
-  it 'should convert symbols to string' do
-    expect(:foo.pascalize).to eq('Foo')
-  end
-
-  it 'should convert symbols with underscores' do
-    expect(:foo_bar.pascalize).to eq('FooBar')
-  end
-end
+describe Rake::Funnel::Extensions::Case::PascalCase do
+  it 'should convert strings' do
+    expect('foo'.pascalize).to eq('Foo')
+  end
+
+  it 'should convert strings with underscores' do
+    expect('foo_bar'.pascalize).to eq('FooBar')
+  end
+
+  it 'should convert symbols to string' do
+    expect(:foo.pascalize).to eq('Foo')
+  end
+
+  it 'should convert symbols with underscores' do
+    expect(:foo_bar.pascalize).to eq('FooBar')
+  end
+end

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

@@ -1,56 +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
+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

@@ -1,33 +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
+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

@@ -1,20 +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
+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