rake-builder 0.9.2 → 0.10.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 60c1b4473a51b3dea752db5616d35f75485f24d9
+  data.tar.gz: f5028bf5de9235c3c68a4f0d270160d5e68fad9d
+SHA512:
+  metadata.gz: 2e2c8faae223acb383fba9cc1727f76eb7c7b0bec433cbad9ab0d1caf2c1a117b0c5c6f810b8ff1c8acd1506b97da746bfd58cc2b6ec1e79805b985a143150ac
+  data.tar.gz: 6ffbfbeadee2ba86245542b14e13518dc364183b9cb7b8aa8d4f25d4b15a1daaeba4e22163143964be56902f84c4396033b072570883b36a57e99b94376a1379

data/README.md

@@ -1,3 +1,5 @@
+[![Build Status](https://secure.travis-ci.org/joeyates/rake-builder.png)][Continuous Integration]
+
 rake-builder
 ============
 
@@ -10,6 +12,7 @@ rake-builder
 [Source code]:   http://github.com/joeyates/rake-builder         "Source code at GitHub"
 [Documentation]: http://rdoc.info/projects/joeyates/rake-builder "Documentation at Rubydoc.info"
 [Rubygem]:       http://rubygems.org/gems/rake-builder           "Ruby gem at rubygems.org"
+[Continuous Integration]: http://travis-ci.org/joeyates/rake-builder "Build status by Travis-CI"
 
 Hello World! Example
 ====================
@@ -122,6 +125,16 @@ If you install a static library, your headers will also be installed.
 Ensure that you use file globs, e.g. './include/**/*.h',
 as these will ensure that your headers are installed in the correct subdirectories.
 
+Problem Resolution
+------------------
+
+If you project does not build, use Rake's `--trace` option to get more
+information about what's going wrong:
+
+```shell
+$ rake --trace
+```
+
 Project
 =======
 

data/lib/rake/builder/version.rb

@@ -2,8 +2,8 @@ module Rake
   class Builder
     module VERSION #:nodoc:
       MAJOR = 0
-      MINOR = 9
-      TINY  = 2
+      MINOR = 10
+      TINY  = 1
 
       STRING = [MAJOR, MINOR, TINY].join('.')
     end

data/lib/rake/microsecond_task.rb

@@ -28,7 +28,7 @@ module Rake
 
       def needed?
         return true if not File.exist?(self.name)
-        @timestamp = File.stat(self.name).mtime if @timestamp.nil?
+        @timestamp ||= File.stat(self.name).mtime
         prerequisites_needed?
       end
 
@@ -52,9 +52,7 @@ module Rake
 
       def needed?
         return true if not File.directory?(self.path)
-        if @timestamp.nil?
-          @timestamp = File.stat(self.path).mtime
-        end
+        @timestamp ||= File.stat(self.path).mtime
         prerequisites_needed?
       end
 

data/spec/unit/compiler_spec.rb

@@ -10,18 +10,11 @@ describe Compiler::Base do
   subject { Compiler::Base.new }
 
   context '#include_paths' do
-    before do
-      File.stub(:exist?).
-        with('/opt/local/include/foo/bar.h').
-        and_return(false)
-    end
+    let(:exists) { false }
 
-    it 'checks extra paths' do
-      File.should_receive(:exist?).
-        with('/opt/local/include/foo/bar.h').
-        and_return(true)
-
-      subject.include_paths(['foo/bar.h'])
+    before do
+      allow(File).to receive(:exist).
+        with('/opt/local/include/foo/bar.h') { exists }
     end
 
     it 'throws an error is the headers are not found' do
@@ -88,12 +81,12 @@ COLLECT_GCC_OPTIONS='-v' '-E' '-mtune=generic' '-march=x86-64'
       EOT
     end
 
-    before { subject.stub(:`).with(/gcc/).and_return(gcc_output) }
+    before { allow(subject).to receive(:`).with(/gcc/) { gcc_output } }
 
     it 'calls gcc' do
-      subject.should_receive(:`).with(/gcc/).and_return(gcc_output)
-
       subject.default_include_paths('c++')
+
+      expect(subject).to have_received(:`).with(/gcc/)
     end
 
     it 'parses gcc output' do
@@ -111,12 +104,12 @@ makedepend: warning:  main.cpp (reading main.h, line 4): cannot find include fil
       EOT
     end
 
-    before { subject.stub(:`).with(/makedepend/).and_return(makedepend_output) }
+    before { allow(subject).to receive(:`).with(/makedepend/) { makedepend_output } }
 
     it 'calls makedepend' do
-      subject.should_receive(:`).with(/makedepend/).and_return(makedepend_output)
-
       subject.missing_headers(['/foo'], ['bar.cpp'])
+
+      expect(subject).to have_received(:`).with(/makedepend/)
     end
 
     it 'returns missing headers' do

data/spec/unit/rake/builder/autoconf/version_spec.rb

@@ -1,116 +1,104 @@
 require 'spec_helper'
 
 describe Rake::Builder::Autoconf::Version do
+  let(:exists) { true }
+  let(:file_content) { '1.2.3' }
   before do
-    File.stub(:exist? => true)
-    File.stub(:read   => '1.2.3')
+    allow(File).to receive(:exist?).with('VERSION') { exists }
+    allow(File).to receive(:read).with('VERSION') { file_content }
   end
+  let(:params) { [] }
+  let(:parameter_version) { '4.5.6' }
+
+  subject { described_class.new(*params) }
 
   context '.new' do
     context 'with parameter' do
       it 'fails if the version parameter is not nn.nn.nn' do
         expect {
-          Rake::Builder::Autoconf::Version.new('hello')
+          described_class.new('hello')
         }.to raise_error(RuntimeError, /badly formatted/)
       end
     end
 
     context 'without parameter' do
       it 'succeeds' do
-        Rake::Builder::Autoconf::Version.new
+        described_class.new
       end
     end
 
-    context 'VERSION file' do
-      it 'checks for a the file' do
-        File.should_receive(:exist?).
-          with('VERSION').
-          and_return(false)
-
-        Rake::Builder::Autoconf::Version.new
-      end
-
-      it 'loads the file' do
-        File.should_receive(:exist?).
-          with('VERSION').
-          and_return(true)
-        File.should_receive(:read).
-          with('VERSION').
-          and_return('1.2.3')
-
-        Rake::Builder::Autoconf::Version.new
-      end
-
-      it 'fails if the version is badly formed' do
-        File.should_receive(:read).
-          with('VERSION').
-          and_return('bad')
+    context 'if the version is badly formed' do
+      let(:file_content) { 'bad' }
 
+      it 'fails' do
         expect {
-          Rake::Builder::Autoconf::Version.new
+          described_class.new
         }.to raise_error(RuntimeError, /file.*?version.*?badly formatted/)
       end
     end
   end
 
   context '#decide' do
-    let(:with_parameter) { Rake::Builder::Autoconf::Version.new('4.5.6') }
-    let(:without_parameter) { Rake::Builder::Autoconf::Version.new }
+    let(:file) { double(File, write: nil) }
 
-    before { File.stub(:open).with('VERSION', 'w') }
+    before do
+      allow(File).to receive(:open).with('VERSION', 'w').and_yield(file)
+    end
 
-    context 'file version is nil' do
-      before { File.stub(:exist? => false) }
+    context 'disk file is absent' do
+      let(:exists) { false }
 
       context 'parameter is nil' do
         it 'raises an error' do
           expect {
-            without_parameter.decide
+            subject.decide
           }.to raise_error(RuntimeError, /Please do one of the following/)
         end
       end
 
       context 'parameter not nil' do
+        let(:params) { [parameter_version] }
+
         it 'saves the version' do
-          File.should_receive(:open).with('VERSION', 'w')
+          subject.decide
 
-          with_parameter.decide
+          expect(file).to have_received(:write).with(parameter_version + "\n")
         end
 
         it 'returns the parameter version' do
-          expect(with_parameter.decide).to eq('4.5.6')
+          expect(subject.decide).to eq(parameter_version)
         end
       end
     end
 
-    context 'file version not nil' do
-      before do
-        File.stub(:exist? => true)
-        File.stub(:read).with('VERSION').and_return("6.6.6\n")
-      end
+    context 'disk file exists' do
+      let(:exists) { true }
 
-      context 'parameter is nil' do
-        it 'returns the file version' do
-          expect(without_parameter.decide).to eq('6.6.6')
+      context 'without parameters' do
+        it 'returns the file version from disk' do
+          expect(subject.decide).to eq(file_content)
         end
       end
 
       context 'parameter not nil' do
-        it 'fails if the two versions differ'do
-          File.should_receive(:read).with('VERSION').and_return("6.6.6\n")
-
-          expect {
-            with_parameter.decide
-          }.to raise_error(RuntimeError, /parameter.*?is different to.*?VERSION/)
+        context 'if the two versions differ'do
+          let(:params) { [parameter_version] }
+
+          it 'fails' do
+            expect {
+              subject.decide
+            }.to raise_error(RuntimeError, /parameter.*?is different to.*?VERSION/)
+          end
         end
 
-        it 'returns the version' do
-          File.should_receive(:read).with('VERSION').and_return("4.5.6\n")
+        context 'if the two versions are the same' do
+          let(:params) { [file_content] }
 
-          expect(with_parameter.decide).to eq('4.5.6')
+          it 'returns the version' do
+            expect(subject.decide).to eq(file_content)
+          end
         end
       end
     end
   end
 end
-

data/spec/unit/rake/builder/configure_ac_spec.rb

@@ -32,21 +32,16 @@ describe Rake::Builder::ConfigureAc do
   end
 
   context '#save' do
-    it 'creates the file' do
-      File.should_receive(:open).with('configure.ac', 'w')
+    let(:file) { double(File, write: nil) }
 
-      subject.save
+    before do
+      allow(File).to receive(:open).with('configure.ac', 'w').and_yield(file)
     end
 
     it 'saves the content' do
-      file = stub('File')
-      File.stub(:open).with('configure.ac', 'w') do |&block|
-        block.call file
-      end
-
-      file.should_receive(:write).with(/AC_PREREQ\(2\.61\)/)
-
       subject.save
+
+      expect(file).to have_received(:write).with(/AC_PREREQ\(2\.61\)/)
     end
   end
 end

data/spec/unit/rake/builder/install_spec.rb

@@ -2,99 +2,110 @@ require 'spec_helper'
 
 describe Rake::Builder::Installer do
   let(:destination_path) { '/destination/path' }
-  let(:destination_pathname) { '/destination/path/install' }
+  let(:destination_pathname) { File.join(destination_path, 'install') }
+  let(:destination_path_writable) { true }
+
+  before do
+    allow(File).to receive(:writable?).with(destination_path) { destination_path_writable }
+  end
 
   context '#install' do
     let(:file_to_install) { '/file/to/install' }
+    let(:file_to_install_exists) { true }
+    let(:destination_path_exists) { true }
+    let(:destination_path_directory) { true }
+    let(:destination_pathname_file) { true }
+    let(:destination_pathname_writable) { true }
 
     before do
-      File.stub(:exist?).with(file_to_install).and_return(true)
-      File.stub(:exist?).with(destination_path).and_return(true)
-      File.stub(:directory?).with(destination_path).and_return(true)
-      File.stub(:writable?).with(destination_path).and_return(true)
-      File.stub(:file?).with(destination_pathname).and_return(false)
-      File.stub(:writable?).with(destination_pathname).and_return(true)
-      FileUtils.stub(:copy_file).with(file_to_install, destination_path)
+      allow(File).to receive(:exist?).with(file_to_install) { file_to_install_exists }
+      allow(File).to receive(:exist?).with(destination_path) { destination_path_exists }
+      allow(File).to receive(:directory?).with(destination_path) { destination_path_directory }
+      allow(File).to receive(:file?).with(destination_pathname) { destination_pathname_file }
+      allow(File).to receive(:writable?).with(destination_pathname) { destination_pathname_writable }
+      allow(FileUtils).to receive(:copy_file).with(file_to_install, destination_path)
     end
 
-    it 'checks the source exists' do
-      File.should_receive(:exist?).with(file_to_install).and_return(true)
+    context 'if the source does not exist' do
+      let(:file_to_install_exists) { false }
 
-      subject.install file_to_install, destination_path
+      it 'fails' do
+        expect {
+          subject.install file_to_install, destination_path
+        }.to raise_error(RuntimeError, /does not exist/)
+      end
     end
 
-    it 'fails if the source does not exist' do
-      File.stub(:exist?).with(file_to_install).and_return(false)
+    context 'if the destination directory does not exist' do
+      let(:destination_path_exists) { false }
 
-      expect {
-        subject.install file_to_install, destination_path
-      }.to raise_error(RuntimeError, /does not exist/)
+      it 'fails' do
+        expect {
+          subject.install file_to_install, destination_path
+        }.to raise_error(RuntimeError, /does not exist/)
+      end
     end
 
-    it 'checks the destination directory exists' do
-      File.should_receive(:exist?).with(destination_path).and_return(false)
+    context 'if the destination is not a directory' do
+      let(:destination_path_directory) { false }
 
-      expect {
-        subject.install file_to_install, destination_path
-      }.to raise_error(RuntimeError, /does not exist/)
+      it 'fails' do
+        expect {
+          subject.install file_to_install, destination_path
+        }.to raise_error(RuntimeError, /is not a directory/)
+      end
     end
 
-    it 'checks the destination is a directory' do
-      File.should_receive(:directory?).with(destination_path).and_return(false)
+    context 'if it cannot overwrite an existing destination file' do
+      let(:destination_pathname_file) { true }
+      let(:destination_pathname_writable) { false }
 
-      expect {
-        subject.install file_to_install, destination_path
-      }.to raise_error(RuntimeError, /is not a directory/)
-    end
-
-    it 'check it can overwrite an existing destination file' do
-      File.stub(:file?).with(destination_pathname).and_return(true)
-      File.stub(:writable?).with(destination_pathname).and_return(false)
-
-      expect {
-        subject.install file_to_install, destination_path
-      }.to raise_error(RuntimeError, /cannot be overwritten/)
+      it 'fails' do
+        expect {
+          subject.install file_to_install, destination_path
+        }.to raise_error(RuntimeError, /cannot be overwritten/)
+      end
     end
 
     it 'copies the file to the destination' do
-      FileUtils.should_receive(:copy_file).with(file_to_install, destination_path)
-
       subject.install file_to_install, destination_path
+
+      expect(FileUtils).to have_received(:copy_file).with(file_to_install, destination_path)
     end
   end
 
   context '#uninstall' do
+    let(:destination_pathname_exist) { true }
+
     before do
-      File.stub(:exist?).with(destination_pathname).and_return(true)
-      File.stub(:writable?).with(destination_path).and_return(true)
-      File.stub(:unlink).with(destination_pathname)
+      allow(File).to receive(:exist?).with(destination_pathname) { destination_pathname_exist }
+      allow(File).to receive(:unlink).with(destination_pathname)
     end
 
-    it 'checks if the file exists' do
-      File.should_receive(:exist?).with(destination_pathname).and_return(true)
+    context 'if the file does not exist' do
+      let(:destination_pathname_exist) { false }
 
-      subject.uninstall destination_pathname
-    end
-
-    it 'does nothing if the file does not exist' do
-      File.should_receive(:exist?).with(destination_pathname).and_return(false)
-      File.should_not_receive(:unlink)
+      it 'does nothing' do
+        subject.uninstall destination_pathname
 
-      subject.uninstall destination_pathname
+        expect(File).to_not have_received(:unlink)
+      end
     end
 
-    it 'fails if the directory is not writable' do
-      File.should_receive(:writable?).with(destination_path).and_return(false)
+    context 'if the directory is not writable' do
+      let(:destination_path_writable) { false }
 
-      expect {
-        subject.uninstall destination_pathname
-      }.to raise_error(RuntimeError, /directory.*?writable/)
+      it 'fails' do
+        expect {
+          subject.uninstall destination_pathname
+        }.to raise_error(RuntimeError, /directory.*?writable/)
+      end
     end
 
     it 'deletes the file' do
-      File.should_receive(:unlink).with(destination_pathname)
-
       subject.uninstall destination_pathname
+
+      expect(File).to have_received(:unlink).with(destination_pathname)
     end
   end
 end