rake-builder 0.7.0 → 0.8.0

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

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Rake::Builder::LocalConfig do
+  let(:local_config_file) { 'local_config' }
+  let(:include_paths) { ['/foo/bar'] }
+  let(:compilation_options) { ['foo', 'bar'] }
+  let(:config_data) do
+    {
+      :rake_builder => {
+        :config_file => {:version => '1.1'},
+      },
+      :include_paths => include_paths,
+      :compilation_options => compilation_options,
+    }
+  end
+  let(:bad_config_data) do
+    config_data[:rake_builder][:config_file][:version] = '0.1'
+    config_data
+  end
+
+  before { YAML.stub(:load_file).and_return(config_data) }
+
+  subject { Rake::Builder::LocalConfig.new(local_config_file) }
+
+  context '#load' do
+    it 'loads the file' do
+      YAML.should_receive(:load_file).and_return(config_data)
+
+      subject.load
+    end
+
+    it 'fails if the version is not recognized' do
+      YAML.should_receive(:load_file).and_return(bad_config_data)
+
+      expect {
+        subject.load
+      }.to raise_error(Rake::Builder::Error, /version incorrect/)
+    end
+
+    it 'sets the include_paths' do
+      subject.load
+
+      expect(subject.include_paths).to eq(include_paths)
+    end
+
+    it 'sets compilation_options' do
+      subject.load
+
+      expect(subject.compilation_options).to eq(compilation_options)
+    end
+  end
+end
+

data/spec/unit/rake/builder/logger/formatter_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe 'Rake::Builder::Logger::Formatter' do
+  let(:formatter) { Rake::Builder::Logger::Formatter.new }
+  let(:stream) { StringIO.new }
+  let(:logger) do
+    logger = Logger.new(stream)
+    logger.formatter = formatter
+    logger
+  end
+
+  context '#call' do
+    it 'only prints the supplied string' do
+      logger.info 'foo'
+
+      expect(stream.string).to eq("foo\n")
+    end
+  end
+end
+

data/spec/unit/rake/builder/presenters/makefile/builder_presenter_spec.rb

@@ -0,0 +1,163 @@
+require 'spec_helper'
+
+describe Rake::Builder::Presenters::Makefile::BuilderPresenter do
+  def self.compiler; 'the_compiler'; end
+  def self.compiler_flags; 'the_compiler_flags'; end
+  def self.linker; 'the_linker'; end
+  def self.link_flags; 'the_link_flags'; end
+  def self.objects_path; '/objects'; end
+
+  let(:executable_target) { 'the_executable' }
+  let(:shared_library_target) { 'libshared.so' }
+  let(:static_library_target) { 'libstatic.a' }
+  let(:label) { 'the_label' }
+  let(:source_files) { ['/sources/one.c', '/sources/two.c'] }
+  let(:object_files) { ['/objects/one.o', '/objects/two.o'] }
+  let(:makefile_name) { 'the_makefile' }
+  let(:common_attributes) do
+    {
+      :label => label,
+      :compiler => self.class.compiler,
+      :compiler_flags => self.class.compiler_flags,
+      :linker => self.class.linker,
+      :link_flags => self.class.link_flags,
+      :objects_path => self.class.objects_path,
+      :source_files => source_files,
+      :object_files => object_files,
+      :makefile_name => makefile_name,
+    }
+  end
+  let(:executable_attributes) do
+    common_attributes.merge(
+      :target => executable_target,
+      :target_type => :executable,
+    )
+  end
+  let(:static_library_attributes) do
+    common_attributes.merge(
+      :target => static_library_target,
+      :target_type => :static_library,
+    )
+  end
+  let(:shared_library_attributes) do
+    common_attributes.merge(
+      :target => shared_library_target,
+      :target_type => :shared_library,
+    )
+  end
+  
+  let(:executable_builder) { stub('Rake::Builder', executable_attributes) }
+  let(:static_library_builder) { stub('Rake::Builder', static_library_attributes) }
+  let(:shared_library_builder) { stub('Rake::Builder', shared_library_attributes) }
+
+  let(:executable_subject) { Rake::Builder::Presenters::Makefile::BuilderPresenter.new(executable_builder) }
+  let(:static_library_subject) { Rake::Builder::Presenters::Makefile::BuilderPresenter.new(static_library_builder) }
+  let(:shared_library_subject) { Rake::Builder::Presenters::Makefile::BuilderPresenter.new(shared_library_builder) }
+
+  context '.new' do
+    it 'takes one parameter' do
+      expect {
+        Rake::Builder::Presenters::Makefile::BuilderPresenter.new
+      }.to raise_error(ArgumentError, /wrong number of arguments/)
+    end
+
+    it 'fails with unknown target types' do
+    end
+  end
+
+  context '#to_s' do
+    it 'fails with unknown target types' do
+      executable_builder.should_receive(:target_type).any_number_of_times.and_return(:foo)
+
+      expect {
+        Rake::Builder::Presenters::Makefile::BuilderPresenter.new(executable_builder)
+      }.to raise_error(RuntimeError, /Unknown.*?target type/)
+    end
+
+    context 'target' do
+      context 'for executable' do
+        it 'is executable' do
+          expect(executable_subject.to_s).to include("EXECUTABLE_TARGET = #{executable_target}")
+        end
+      end
+
+      context 'for library' do
+        it 'is a library' do
+          expect(static_library_subject.to_s).to include("LIB_TARGET = #{static_library_target}")
+        end
+      end
+    end
+
+    context 'variables' do
+      [
+        ['COMPILER', compiler],
+        ['COMPILER_FLAGS', compiler_flags],
+        ['LINKER', linker],
+        ['LINK_FLAGS', link_flags],
+        ['OBJECT_DIR', objects_path],
+      ].each do |name, value|
+        it "declares '#{name}'" do
+          expect(executable_subject.to_s).to match(/#{name}\s+=\s+#{value}/)
+        end
+      end
+
+      it "declares 'OBJECTS'" do
+        expect(executable_subject.to_s).to match(%r(OBJECTS\s+=\s+\$\(OBJECT_DIR\)/one\.o \$\(OBJECT_DIR\)/two\.o))
+      end
+    end
+
+    context 'actions' do
+      context 'for executable' do
+        it 'builds the target' do
+          expected = <<EOT
+$(EXECUTABLE_TARGET): $(OBJECTS)
+	$(LINKER) $(LINK_FLAGS) -o $(EXECUTABLE_TARGET) $(OBJECTS)
+EOT
+          expect(executable_subject.to_s).to include(expected)
+        end
+      end
+
+      context 'for static library' do
+        it 'builds the target' do
+          expected = <<EOT
+$(LIB_TARGET): $(OBJECTS)
+	rm -f $(LIB_TARGET)
+	ar -cq $(LIB_TARGET) $(OBJECTS)
+	ranlib $(LIB_TARGET)
+EOT
+          expect(static_library_subject.to_s).to include(expected)
+        end
+      end
+
+      context 'for shared library' do
+        it 'builds the target' do
+          expected = <<EOT
+$(LIB_TARGET): $(OBJECTS)
+	$(LINKER) -shared -o $(LIB_TARGET) $(OBJECTS) $(LINK_FLAGS)
+EOT
+          expect(shared_library_subject.to_s).to include(expected)
+        end
+      end
+    end
+  end
+
+  context '#save' do
+    it 'creates the makefile' do
+      File.should_receive(:open).with(makefile_name, 'w')
+
+      executable_subject.save
+    end
+
+    it 'saves' do
+      file = stub('File')
+      File.stub(:open).with(makefile_name, 'w') do |&block|
+        block.call file
+      end
+
+      file.should_receive(:write).with(/COMPILER.*?= the_compiler/)
+
+      executable_subject.save
+    end
+  end
+end
+

data/spec/unit/rake/builder/presenters/makefile_am/builder_presenter_spec.rb

@@ -15,7 +15,7 @@ describe Rake::Builder::Presenters::MakefileAm::BuilderPresenter do
         'Rake::Builder',
         :is_library?               => false,
         :label                     => 'fubar',
-        :source_paths              => ['path/to/1', 'path/to/2'],
+        :source_files              => ['path/to/1', 'path/to/2'],
         :compiler_flags            => '-D FOO -D BAR',
         :library_dependencies_list => '-lfoo -lbar'
       )
@@ -41,7 +41,9 @@ describe Rake::Builder::Presenters::MakefileAm::BuilderPresenter do
       expect(subject.to_s).to match(/fubar_CPPFLAGS\s+=\s+-D FOO -D BAR/)
     end
 
-    it 'ends with a blank line'
+    it 'ends with a blank line' do
+      expect(subject.to_s).to end_with("\n")
+    end
 
     context 'library builder' do
       subject { Rake::Builder::Presenters::MakefileAm::BuilderPresenter.new(library) }

data/spec/unit/rake/builder/task_definers/builder_task_definer_spec.rb

@@ -129,6 +129,12 @@ describe Rake::Builder::BuilderTaskDefiner do
 
         expect(Rake::Task.task_defined?('foo')).to be_true
       end
+
+      it 'does not fiddle up the local_config file' do
+        subject.run
+
+        expect(Rake::Task['foo:load_local_config'].prerequisites).to eq([namespaced_builder.local_config])
+      end
     end
   end
 

data/spec/unit/rake/builder_spec.rb

@@ -1,7 +1,26 @@
 require 'spec_helper'
 
 describe Rake::Builder do
-  include RakeBuilderHelper
+  include InputOutputTestHelper
+  
+  let(:target_pathname) { File.join('foo', 'bar', 'my_prog.exe') }
+  let(:source_paths) { ['src/file1.cpp'] }
+  let(:builder) do
+    Rake::Builder.new do |b|
+      b.target               = target_pathname
+      b.library_dependencies = ['foo', 'bar']
+    end
+  end
+  let(:installer) do
+    stub(
+      'Rake::Builder::Installer',
+      :install => nil
+    )
+  end
+
+  before do
+    Rake::Path.stub(:find_files).and_return(source_paths)
+  end
 
   context '.create_autoconf' do
     let(:version) { stub('Rake::Builder::Autoconf::Autoconf::Version', :decide => 'qux') }
@@ -59,41 +78,397 @@ describe Rake::Builder do
     end
   end
 
+  context '.new' do
+    it 'fails without a block' do
+      expect {
+        Rake::Builder.new
+      }.to raise_error(RuntimeError, 'No block given')
+    end
+
+    it 'raises an error when the target is an empty string' do
+      expect {
+        Rake::Builder.new { |b| b.target = '' }
+      }.to raise_error(Rake::Builder::Error, 'The target name cannot be an empty string')
+    end
+
+    it 'raises an error when the target is nil' do
+      expect {
+        Rake::Builder.new { |b| b.target = nil }
+      }.to raise_error(Rake::Builder::Error, 'The target name cannot be nil')
+    end
+
+    it 'raises an error when the supplied target_type is unknown' do
+      expect {
+        Rake::Builder.new { |b| b.target_type = :foo }
+      }.to raise_error(Rake::Builder::Error, 'Building foo targets is not supported')
+    end
+
+    it 'remembers the Rakefile path' do
+      Rake::Path.stub(:find_files => ['main.cpp'])
+      here = File.dirname(File.expand_path(__FILE__))
+
+      builder = Rake::Builder.new {}
+
+      expect(builder.rakefile_path).to eq(here)
+    end
+  end
+
+  context '#build' do
+    before do
+      @target_exists = [false, true]
+      File.stub(:exist?).with(builder.target) { @target_exists.shift }
+      builder.stub(:system => nil)
+      `(exit 0)` # set $? to a successful Process::Status
+    end
+
+    it 'checks if the old target exists' do
+      File.should_receive(:exist?).with(builder.target) { @target_exists.shift }
+
+      builder.build
+    end
+
+    it 'deletes the old target' do
+      @target_exists = [true, true]
+
+      File.should_receive(:unlink).with(builder.target)
+
+      builder.build
+    end
+
+    it 'fails if a build command fails' do
+      `(exit 1)` # set $? to a failing Process::Status
+
+      expect {
+        builder.build
+      }.to raise_error(Rake::Builder::BuildFailure, /command.*?failed/)
+    end
+
+    it 'fails if the target is missing afterwards' do
+      @target_exists = [false, false]
+
+      expect {
+        builder.build
+      }.to raise_error(Rake::Builder::BuildFailure, /not created/)
+    end
+  end
+
+  context '#run' do
+    before do
+      @old_dir = Dir.pwd
+      Dir.stub(:chdir).with(builder.rakefile_path)
+      builder.stub(:system)
+      Dir.stub(:chdir).with(@old_dir)
+    end
+
+    it 'changes directory to the Rakefile path' do
+      Dir.should_receive(:chdir).with(builder.rakefile_path)
+
+      capturing_output do
+        builder.run
+      end
+    end
+
+    it 'runs the executable' do
+      builder.should_receive(:system).with('./' + builder.target, anything)
+
+      capturing_output do
+        builder.run
+      end
+    end
+
+    it 'outputs the stdout results, then the stderr results' do
+      builder.stub(:system) do |command|
+        $stdout.puts 'standard output'
+        $stderr.puts 'error output'
+      end
+
+      stdout, stderr = capturing_output do
+        builder.run
+      end
+
+      expect(stdout).to eq("standard output\n")
+      expect(stderr).to eq("error output\n")
+    end
+
+    it 'raises and error is the program does not run successfully' do
+      builder.stub(:system) { `(exit 1)` } # set $? to a failing Process::Status
+
+      expect {
+        builder.run
+      }.to raise_error(Exception, /Running.*?failed with status 1/)
+    end
+
+    it 'restores the preceding working directory, even after errors' do
+      builder.stub(:system).and_raise('foo')
+
+      Dir.should_receive(:chdir).with(@old_dir)
+
+      builder.run rescue nil
+    end
+  end
+
+  context '#clean' do
+    it 'checks if files exist' do
+      exists = []
+      File.stub(:exist?) { |file| exists << file; false }
+
+      builder.clean
+
+      expect(exists).to eq(builder.generated_files)
+    end
+
+    it 'deletes generated files' do
+      deletes = []
+      File.stub(:exist? => true)
+      File.stub(:unlink) { |file| deletes << file }
+
+      builder.clean
+
+      expect(deletes).to eq(builder.generated_files)
+    end
+  end
+
+  context '#header_search_paths' do
+    it 'is deprecated' do
+      stdout, stderr = capturing_output do
+        builder.header_search_paths
+      end
+
+      expect(stderr).to include('Deprecation notice')
+    end
+  end
+
+  context '#header_search_paths=' do
+    it 'is deprecated' do
+      stdout, stderr = capturing_output do
+        builder.header_search_paths = []
+      end
+
+      expect(stderr).to include('Deprecation notice')
+    end
+  end
+
+  context '#target' do
+    it "defaults to 'a.out'" do
+      Rake::Path.stub(:find_files => ['main.cpp'])
+
+      builder = Rake::Builder.new {}
+
+      expect(builder.target).to end_with('/a.out')
+    end
+  end
+
   context '#primary_name' do
     it 'returns a relative path' do
-      here = File.expand_path(File.dirname(__FILE__))
-      target_pathname = File.join(here, 'my_prog')
-      builder = cpp_task(:executable) { |b| b.target = target_pathname }
-
-      expect(builder.primary_name).to eq(File.join('unit', 'rake', 'my_prog'))
+      expect(builder.primary_name).to eq(File.join('foo', 'bar', 'my_prog.exe'))
     end
   end
 
   context '#label' do
     it 'replaces dots with underscores' do
-      builder = cpp_task(:executable) { |b| b.target = 'my_prog.exe' }
+      expect(builder.label).to eq(File.join('foo', 'bar', 'my_prog_exe'))
+    end
+  end
+
+  context '#target_type' do
+    [
+      ['my_program',   :executable],
+      ['libstatic.a',  :static_library],
+      ['libshared.so', :shared_library],
+    ].each do |name, type|
+      it "recognises '#{name}' as '#{type}'" do
+        Rake::Path.stub(:find_files).and_return(['file'])
 
-      expect(builder.label).to eq('my_prog_exe')
+        builder = Rake::Builder.new { |b| b.target = name }
+
+        expect(builder.target_type).to eq(type)
+      end
     end
   end
 
-  context '#source_paths' do
-    it 'returns source files' do
-      builder = cpp_task(:executable)
+  context '#is_library?' do
+    [
+      [:static_library, 'libbaz.a',  true],
+      [:shared_library, 'libfoo.so', true],
+      [:executable,     'baz',       false]
+    ].each do |type, target, is_library|
+      example type do
+        builder = Rake::Builder.new do |b|
+          b.target = target
+        end
+        expect(builder.is_library?).to eq(is_library)
+      end
+    end
+  end
+
+  context '#source_files' do
+    it 'finds files with the .cpp extension' do
+      Rake::Path.should_receive(:find_files).with(anything, 'cpp').and_return(['a.cpp'])
+
+      builder
+    end
+
+    it 'should allow configuration of source extension' do
+      Rake::Path.should_receive(:find_files).with(anything, 'cc').and_return(['a.cc'])
 
-      expect(builder.source_paths).to eq(['cpp_project/main.cpp'])
+      Rake::Builder.new do |b|
+        b.source_file_extension = 'cc'
+      end
     end
   end
 
-  context '#library_dependencies_list' do
-    subject { cpp_task(:executable) { |b| b.library_dependencies = ['foo', 'bar'] } }
+  context '#object_path' do
+    let(:source_path) { 'foo/bar/baz.cpp' }
 
+    subject { builder.object_path(source_path) }
+
+    it 'substitutes the source extension with the object one' do
+      expect(subject).to end_with('.o')
+    end
+
+    it 'adds the objects path' do
+      expect(subject).to start_with(builder.objects_path)
+    end
+  end
+
+  context '#library_dependencies_list' do
     it 'is a string' do
-      expect(subject.library_dependencies_list).to be_a(String)
+      expect(builder.library_dependencies_list).to be_a(String)
     end
 
     it 'lists libraries' do
-      expect(subject.library_dependencies_list).to eq('-lfoo -lbar')
+      expect(builder.library_dependencies_list).to eq('-lfoo -lbar')
+    end
+  end
+
+  context '#create_makedepend_file' do
+    before do
+      builder.stub(:system).with('which makedepend >/dev/null') do
+        `(exit 0)` # set $? to a successful Process::Status
+      end
+
+      builder.stub(:system).with(/makedepend -f-/, anything)
+    end
+
+    it 'fails if makedepend is missing' do
+      builder.stub(:system).with('which makedepend >/dev/null') do
+        `(exit 1)` # set $? to a successful Process::Status
+      end
+
+      expect {
+        builder.create_makedepend_file
+      }.to raise_error(RuntimeError, 'makedepend not found')
+    end
+
+    it 'calls makedepend' do
+      builder.should_receive(:system).with(/makedepend -f-/, anything)
+
+      builder.create_makedepend_file
+    end
+  end
+
+  context '#load_makedepend' do
+    let(:content) do
+      lines = []
+      lines << 'Some text'
+      builder.source_files.each do |f|
+        source_path_object = f.gsub(/\.[^\.]+$/, '.o')
+        lines << source_path_object + ': header1.h'
+      end
+      lines.join("\n")
+    end
+
+    before do
+      File.stub(:read).with(builder.makedepend_file).and_return(content)
+    end
+
+    it 'opens the file' do
+      File.should_receive(:read).with(builder.makedepend_file).and_return(content)
+
+      builder.load_makedepend
+    end
+
+    it 'returns a map of sources to headers' do
+      expected = builder.object_files.reduce({}) do |a, e|
+        a[e] = ['header1.h']
+        a
+      end
+
+      expect(builder.load_makedepend).to eq(expected)
+    end
+  end
+
+  context '#load_local_config' do
+    let(:config_include_paths) { ['/path/one', '/path/two'] }
+    let(:config_compilation_options) { ['opt1', 'opt2'] }
+    let(:local_config) do
+      stub(
+        'Rake::Builder::LocalConfig',
+        :load => nil,
+        :include_paths => config_include_paths,
+        :compilation_options => config_compilation_options,
+      )
+    end
+
+    before { Rake::Builder::LocalConfig.stub(:new => local_config) }
+
+    it 'loads local config' do
+      Rake::Builder::LocalConfig.should_receive(:new).
+        with(/\.rake-builder/).and_return(local_config)
+      local_config.should_receive(:load).with()
+
+      builder.load_local_config
+    end
+
+    it 'adds include paths' do
+      original = builder.include_paths.clone
+
+      builder.load_local_config
+
+      expect(builder.include_paths).to eq(original + config_include_paths)
+    end
+
+    it 'adds compilation options' do
+      original = builder.compilation_options.clone
+
+      builder.load_local_config
+
+      expect(builder.compilation_options).to eq(original + config_compilation_options)
+    end
+  end
+
+  context '#install' do
+    before { Rake::Builder::Installer.stub(:new).and_return(installer) }
+
+    it 'installs the target' do
+      Rake::Builder::Installer.should_receive(:new).and_return(installer)
+      installer.should_receive(:install).with(builder.target, anything)
+
+      builder.install
+    end
+
+    it 'installs headers for static libraries' do
+      installer.stub(:install).with(builder.target, anything)
+      File.should_receive(:file?).with('header.h').and_return(true)
+      installer.should_receive(:install).with('header.h', anything)
+
+      builder = Rake::Builder.new do |b|
+        b.target              = 'libthe_static_library.a'
+        b.installable_headers = ['header.h']
+      end
+
+      builder.install
+    end
+  end
+
+  context '#uninstall' do
+    before { Rake::Builder::Installer.stub(:new).and_return(installer) }
+
+    it 'uninstalls' do
+      installed_path = File.join(builder.install_path, builder.target_basename)
+      installer.should_receive(:uninstall).with(installed_path)
+
+      builder.uninstall
     end
   end
 end