rake-builder 0.7.0 → 0.8.0

data/Rakefile

@@ -4,17 +4,20 @@ require 'rspec/core/rake_task'
 
 task :default => :spec
 
-RSpec::Core::RakeTask.new do | t |
+RSpec::Core::RakeTask.new do |t|
   t.pattern = 'spec/**/*_spec.rb'
 end
 
 if RUBY_VERSION < '1.9'
-
-  RSpec::Core::RakeTask.new( 'spec:rcov' ) do |t|
+  RSpec::Core::RakeTask.new('spec:rcov') do |t|
     t.pattern   = 'spec/**/*_spec.rb'
     t.rcov      = true
-    t.rcov_opts = [ '--exclude', 'spec/,/gems/' ]
+    t.rcov_opts = ['--exclude', 'spec/,/gems/']
+  end
+else
+  desc 'Run specs and create coverage output'
+  RSpec::Core::RakeTask.new('spec:coverage') do |t|
+    t.pattern = ['spec/gather_rspec_coverage.rb', 'spec/**/*_spec.rb']
   end
-
 end
 

data/examples/05_tests/Rakefile

@@ -5,15 +5,15 @@ require 'rake/builder'
 Rake::Builder.new do |builder|
   builder.target               = 'unit'
   builder.source_search_paths  = [ 'src' ]
-  builder.header_search_paths  = [ 'include' ]
+  builder.installable_headers  = [ 'include' ]
 end
 
 Rake::Builder.new do |builder|
   builder.task_namespace       = 'test'
   builder.target               = 'test_unit'
   builder.source_search_paths  = [ 'test', 'src/units.*' ]
-  builder.header_search_paths  = [ 'include' ]
+  builder.installable_headers  = [ 'include' ]
   builder.objects_path         = 'test'
-  builder.compilation_options  = '-DDEBUG'
+  builder.compilation_options  = [ '-DDEBUG' ]
 end
 

data/examples/05_tests/include/units.h

@@ -1,8 +1,8 @@
 #ifndef __UNITS_H__
 #define __UNITS_H__
 
-#include <ostream>;
-#include <string>;
+#include <ostream>
+#include <string>
 using namespace std;
 
 class Unit

data/lib/compiler.rb

@@ -1,22 +1,20 @@
-
 module Compiler
-
   class Base
-    EXTRA_PATHS = [ '/opt/local/include' ]
+    EXTRA_PATHS = ['/opt/local/include']
 
-    def self.for( compiler )
-      COMPILERS[ compiler ].new
+    def self.for(compiler)
+      COMPILERS[compiler].new
     end
 
     def initialize
       @paths = {}
     end
 
-    def include_paths( headers )
+    def include_paths(headers)
       paths = []
-      headers.each do | header |
-        path = find_header( header )
-        raise "Can't find header '#{ header }' in any known include path" if path.nil?
+      headers.each do |header|
+        path = find_header(header)
+        raise "Can't find header '#{header}' in any known include path" if path.nil?
         paths << path
       end
       paths.uniq
@@ -24,29 +22,27 @@ module Compiler
 
     private
 
-    def find_header( header )
-      EXTRA_PATHS.each do | path |
-        if File.exist?( "#{ path }/#{ header }" )
+    def find_header(header)
+      EXTRA_PATHS.each do |path|
+        if File.exist?("#{path}/#{header}")
           return path
         end
       end
       nil
     end
-
   end
 
   class GCC < Base
-
-    def self.framework_path( framework, qt_major )
-      "/Library/Frameworks/#{ framework }.framework/Versions/#{ qt_major }/Headers"
+    def self.framework_path(framework, qt_major)
+      "/Library/Frameworks/#{framework}.framework/Versions/#{qt_major}/Headers"
     end
 
-    def default_include_paths( language )
-      return @paths[ language ] if @paths[ language ]
+    def default_include_paths(language)
+      return @paths[language] if @paths[language]
 
       paths = []
       # Below is the recommended(!) way of getting standard search paths from GCC
-      output = `echo | LANG=C gcc -v -x #{ language } -E - 2>&1 1>/dev/null`
+      output = `echo | LANG=C gcc -v -x #{language} -E - 2>&1 1>/dev/null`
       collecting = false
       output.each_line do | line |
         case
@@ -61,24 +57,23 @@ module Compiler
         end
       end
 
-      @paths[ language ] = paths
+      @paths[language] = paths
     end
 
-    def missing_headers( include_paths, source_files )
-      include_path = include_paths.map { | path | "-I#{ path }" }.join( ' ' )
-      command      = "makedepend -f- -- #{ include_path } -- #{ source_files.join( ' ' ) } 2>&1 1>/dev/null"
-      output       = `#{ command }`
+    def missing_headers(include_paths, source_files)
+      include_path = include_paths.map { |path| "-I#{path}"}.join(' ')
+      command      = "makedepend -f- -- #{include_path} -- #{source_files.join(' ')} 2>&1 1>/dev/null"
+      output       = `#{command}`
       missing      = []
-      output.each_line do | line |
-        match = line.match( /cannot find include file "([^"]*)"/m )
-        missing << match[ 1 ] if match
+      output.each_line do |line|
+        match = line.match(/cannot find include file "([^"]*)"/m)
+        missing << match[1] if match
       end
 
       missing
     end
-
   end
 
-  COMPILERS = { :gcc => GCC }
-
+  COMPILERS = {:gcc => GCC}
 end
+

data/lib/rake/builder.rb

@@ -4,6 +4,8 @@ require 'rake'
 require 'rake/builder/autoconf/version'
 require 'rake/builder/configure_ac'
 require 'rake/builder/error'
+require 'rake/builder/installer'
+require 'rake/builder/local_config'
 require 'rake/builder/logger/formatter'
 require 'rake/builder/presenters/makefile/builder_presenter'
 require 'rake/builder/presenters/makefile_am/builder_presenter'
@@ -11,7 +13,7 @@ require 'rake/builder/presenters/makefile_am/builder_collection_presenter'
 require 'rake/builder/task_definers/builder_task_definer'
 require 'rake/builder/task_definers/builder_collection_task_definer'
 require 'rake/path'
-require 'rake/microsecond'
+require 'rake/microsecond_task'
 require 'rake/once_task'
 require 'compiler'
 
@@ -112,12 +114,12 @@ module Rake
     attr_accessor :installable_headers
 
     def header_search_paths
-      warn 'Deprecation notice: Rake::Builder#header_search_paths has be replaced by Rake::Builder#installable_headers'
+      warn 'Deprecation notice: Rake::Builder#header_search_paths has been replaced by Rake::Builder#installable_headers'
       installable_headers
     end
 
     def header_search_paths=(paths)
-      warn 'Deprecation notice: Rake::Builder#header_search_paths has be replaced by Rake::Builder#installable_headers'
+      warn 'Deprecation notice: Rake::Builder#header_search_paths has been replaced by Rake::Builder#installable_headers'
       installable_headers = paths
     end
 
@@ -187,6 +189,7 @@ module Rake
     Rake::Builder::BuilderCollectionTaskDefiner.new.run
 
     def initialize(&block)
+      raise 'No block given' if block.nil?
       save_rakefile_info(block)
       set_defaults
       block.call(self)
@@ -195,14 +198,12 @@ module Rake
       self.class.instances << self
     end
 
-    def run
-      command = "cd #{rakefile_path} && #{target}"
-      puts shell(command, Logger::INFO)
-    end
+    ################################################
+    # main actions
 
     def build
       logger.debug "Building '#{target}'"
-      system "rm -f #{target}"
+      File.unlink(target) if File.exist?(target)
       build_commands.each do |command|
         stdout, stderr = shell(command)
         raise BuildFailure.new("Error: command '#{command}' failed: #{stderr} #{stdout}") if not $?.success?
@@ -210,14 +211,40 @@ module Rake
       raise BuildFailure.new("'#{target}' not created") if not File.exist?(target)
     end
 
-    def create_local_config
-      logger.debug "Creating file '#{local_config }'"
-      added_includes = compiler_data.include_paths(missing_headers)
-      config = Rake::LocalConfig.new(local_config)
-      config.include_paths = added_includes
-      config.save
+    def run
+      old_dir = Dir.pwd
+      Dir.chdir rakefile_path
+      command = File.join('.', target)
+      begin
+        output, error = shell(command, ::Logger::INFO)
+        $stdout.print output
+        $stderr.print error
+        raise Exception.new("Running #{command} failed with status #{$?.exitstatus}") if not $?.success?
+      ensure
+        Dir.chdir old_dir
+      end
+    end
+
+    def clean
+      generated_files.each do |file|
+        File.unlink(file) if File.exist?(file)
+      end
     end
 
+    def install
+      destination = File.join(install_path, target_basename)
+      Rake::Builder::Installer.new.install target, destination
+      install_headers if target_type == :static_library
+    end
+
+    def uninstall
+      destination = File.join(install_path, target_basename)
+      Rake::Builder::Installer.new.uninstall destination
+    end
+
+    ################################################
+    # helpers invoked by tasks
+
     def create_makedepend_file
       logger.debug 'Creating makedepend file'
       system('which makedepend >/dev/null')
@@ -226,74 +253,80 @@ module Rake
       shell command
     end
 
-    def load_local_config
-      config = Rake::LocalConfig.new(local_config)
-      config.load
-      @include_paths       += Rake::Path.expand_all_with_root(config.include_paths, rakefile_path)
-      @compilation_options += config.compilation_options
-    end
-
     def load_makedepend
-      object_to_source = source_files.inject({}) do |memo, source|
-        mapped_object = source.gsub('.' + source_file_extension, '.o')
-        memo[mapped_object] = source
-        memo
+      content = File.read(makedepend_file)
+      # Replace old-style files with full paths
+      if content =~ %r(^/)
+        create_makedepend_file
+        return load_makedepend
+      end
+
+      # makedepend assumes each .o files will be in the same path as its source
+      real_object_path = source_files.inject({}) do |a, source|
+        source_path_object = source.gsub('.' + source_file_extension, '.o')
+        correct_path_object = object_path(source)
+        a[source_path_object] = correct_path_object
+        a
       end
 
       object_header_dependencies = Hash.new { |h, v| h[v] = [] }
-      File.open(makedepend_file).each_line do |line|
+      content.each_line do |line|
         next if line !~ /:\s/
-        mapped_object_file = $`
+        source_path_object = $`
         header_files = $'.chomp
-        source_file = object_to_source[mapped_object_file]
-        object_file = object_path(source_file)
-        object_header_dependencies[object_file] += header_files.split(' ')
+        object_path_name = real_object_path[source_path_object]
+        object_header_dependencies[object_path_name] += header_files.split(' ')
       end
+
       object_header_dependencies
     end
 
-    def clean
-      generated_files.each do |file|
-        system "rm -f #{file}"
-      end
+    def generated_headers
+      []
     end
 
-    def install
-      destination = File.join(install_path, target_basename)
-      install_file(target, destination)
-      install_headers if target_type == :static_library
+    # Raises an error if there are missing headers
+    def ensure_headers
+      missing = missing_headers
+      return if missing.size == 0
+
+      message = "Compilation cannot proceed as the following header files are missing:\n" + missing.join("\n") 
+      raise Error.new(message)
     end
 
-    def uninstall
-      destination = File.join(install_path, target_basename)
-      if not File.exist?(destination)
-        logger.add(Logger::INFO, "The file '#{destination}' does not exist")
-        return
-      end
-      begin
-        shell "rm '#{destination}'", Logger::INFO
-      rescue Errno::EACCES => e
-        raise Error.new("You do not have permission to uninstall '#{destination}'\nTry re-running the command with 'sudo'", task_namespace)
-      end
+    def load_local_config
+      config = Rake::Builder::LocalConfig.new(local_config)
+      config.load
+      @include_paths       += config.include_paths
+      @compilation_options += config.compilation_options
+    end
+
+    def create_local_config
+      logger.debug "Creating file '#{local_config}'"
+      added_includes = compiler_data.include_paths(missing_headers)
+      config = Rake::Builder::LocalConfig.new(local_config)
+      config.include_paths = added_includes
+      config.save
     end
 
     def compile(source, object)
-      logger.add(Logger::DEBUG, "Compiling '#{source}'")
+      logger.add(::Logger::DEBUG, "Compiling '#{source}'")
       command = "#{compiler} -c #{compiler_flags} -o #{object} #{source}"
       stdout, stderr = shell(command)
       raise BuildFailure.new("Error: command '#{command}' failed: #{stderr} #{stdout}") if not $?.success?
     end
 
-    # Source files found in source_search_paths
-    def source_files
-      return @source_files if @source_files
-      @source_files = find_files( @source_search_paths, @source_file_extension ).uniq.sort
-    end
+    ################################################
+    # public attributes
 
     def is_library?
       [:static_library, :shared_library].include?(target_type)
     end
 
+    def target_basename
+      File.basename(@target)
+    end
+
     def primary_name
       Rake::Path.relative_path(target, rakefile_path, :initial_dot_slash => false)
     end
@@ -302,8 +335,15 @@ module Rake
       primary_name.gsub(%r(\.), '_')
     end
 
-    def source_paths
-      source_files.map{ |file| Rake::Path.relative_path(file, rakefile_path) }
+    # Source files found in source_search_paths
+    def source_files
+      return @source_files if @source_files
+
+      old_dir = Dir.pwd
+      Dir.chdir @rakefile_path
+      @source_files = Rake::Path.find_files(@source_search_paths, source_file_extension).uniq.sort
+      Dir.chdir old_dir
+      @source_files
     end
 
     def object_files
@@ -312,7 +352,7 @@ module Rake
 
     def object_path(source_path_name)
       o_name = File.basename(source_path_name).gsub('.' + source_file_extension, '.o')
-      Rake::Path.expand_with_root(o_name, objects_path)
+      File.join(objects_path, o_name)
     end
 
     def compiler_flags
@@ -323,12 +363,14 @@ module Rake
       flags
     end
 
-    def library_dependencies_list
-      @library_dependencies.map { |lib| "-l#{lib}" }.join(' ')
+    def link_flags
+      flags = [ @linker_options, library_paths_list, library_dependencies_list ]
+      flags << architecture_option if RUBY_PLATFORM =~ /darwin/i
+      flags.join( " " )
     end
 
-    def target_basename
-      File.basename(@target)
+    def library_dependencies_list
+      @library_dependencies.map { |lib| "-l#{lib}" }.join(' ')
     end
 
     def makefile_name
@@ -340,25 +382,6 @@ module Rake
       "Makefile#{ extension }"
     end
 
-    def generated_headers
-      []
-    end
-
-    # Raises an error if there are missing headers
-    def ensure_headers
-      missing = missing_headers
-      return if missing.size == 0
-
-      message = "Compilation cannot proceed as the following header files are missing:\n" + missing.join("\n") 
-      raise Error.new(message)
-    end
-
-    def link_flags
-      flags = [ @linker_options, library_paths_list, library_dependencies_list ]
-      flags << architecture_option if RUBY_PLATFORM =~ /darwin/i
-      flags.join( " " )
-    end
-
     private
 
     # Lists headers referenced by the project's files or includes
@@ -373,21 +396,21 @@ module Rake
     def set_defaults
       @architecture          = 'i386'
       @compiler_data         = Compiler::Base.for(:gcc)
-      @logger                = Logger.new(STDOUT)
-      @logger.level          = Logger::UNKNOWN
-      @logger.formatter      = Formatter.new
+      @logger                = ::Logger.new(STDOUT)
+      @logger.level          = ::Logger::UNKNOWN
+      @logger.formatter      = Rake::Builder::Logger::Formatter.new
       @programming_language  = 'c++'
       @header_file_extension = 'h'
-      @objects_path          = @rakefile_path.dup
+      @objects_path          = '.'
       @library_paths         = []
       @library_dependencies  = []
       @target_prerequisites  = []
-      @source_search_paths   = [@rakefile_path.dup]
-      @target                = 'a.out'
+      @source_search_paths   = ['.']
+      @target                = './a.out'
       @generated_files       = []
       @compilation_options   = []
-      @include_paths         = [File.join(@rakefile_path.dup, 'include')]
-      @installable_headers   = [@rakefile_path.dup]
+      @include_paths         = ['./include']
+      @installable_headers   ||= []
     end
 
     def configure
@@ -402,34 +425,26 @@ module Rake
       @ranlib                ||= KNOWN_LANGUAGES[ @programming_language ][ :ranlib ]
       @source_file_extension ||= KNOWN_LANGUAGES[ @programming_language ][ :source_file_extension ]
 
-      @source_search_paths   = Rake::Path.expand_all_with_root( @source_search_paths, @rakefile_path )
-      @library_paths         = Rake::Path.expand_all_with_root( @library_paths, @rakefile_path )
 
       raise Error.new( "The target name cannot be nil", task_namespace )             if @target.nil?
       raise Error.new( "The target name cannot be an empty string", task_namespace ) if @target == ''
-      @objects_path          = Rake::Path.expand_with_root( @objects_path, @rakefile_path )
 
-      @target                = File.expand_path( @target, @rakefile_path )
       @target_type           ||= to_target_type( @target )
       raise Error.new( "Building #{ @target_type } targets is not supported", task_namespace ) if ! TARGET_TYPES.include?( @target_type )
       @generated_files << @target
 
       @install_path          ||= default_install_path( @target_type )
-      @installable_headers   = Rake::Path.expand_all_with_root( @installable_headers, @rakefile_path )
 
       @linker_options        ||= ''
-      @include_paths         += []
-      @include_paths         = Rake::Path.expand_all_with_root( @include_paths.uniq, @rakefile_path )
-      @generated_files       = Rake::Path.expand_all_with_root( @generated_files, @rakefile_path )
 
       @default_task          ||= :build
       @target_prerequisites  << @rakefile
-      @local_config          = Rake::Path.expand_with_root( '.rake-builder', @rakefile_path )
+      @local_config          = '.rake-builder'
 
       @makedepend_file       = @objects_path + '/.' + target_basename + '.depend.mf'
       @generated_files << @makedepend_file
 
-      raise Error.new( "No source files found", task_namespace ) if source_files.length == 0
+      raise Error.new("No source files found", task_namespace) if source_files.size == 0
     end
 
     def to_target_type(target)
@@ -446,8 +461,7 @@ module Rake
     # Compiling and linking parameters
 
     def include_path
-      paths = @include_paths.map{ | file | Rake::Path.relative_path( file, rakefile_path) }
-      paths.map { |p| "-I#{ p }" }.join( ' ' )
+      @include_paths.map { |p| "-I#{p}" }.join(' ')
     end
 
     def architecture_option
@@ -483,11 +497,6 @@ module Rake
     def file_list(files)
       files.join(' ')
     end
-
-    def find_files( paths, extension )
-      files = Rake::Path.find_files( paths, extension )
-      Rake::Path.expand_all_with_root( files, @rakefile_path )
-    end
     
     def library_paths_list
       @library_paths.map { | path | "-L#{ path }" }.join( " " )
@@ -497,40 +506,39 @@ module Rake
       # TODO: make install_headers_path a configuration option
       install_headers_path = '/usr/local/include'
 
-      project_headers.each do | installable_header |
+      installer = Rake::Builder::Installer.new
+      project_headers.each do |installable_header|
         destination_path = File.join( install_headers_path, installable_header[ :relative_path ] )
         begin
           `mkdir -p '#{ destination_path }'`
         rescue Errno::EACCES => e
           raise Error.new( "Permission denied to created directory '#{ destination_path }'", task_namespace )
         end
-        install_file( installable_header[ :source_file ], destination_path )
+        installer.install installable_header[:source_file], destination_path
       end
     end
 
     def project_headers
-      @installable_headers.reduce( [] ) do | memo, search |
-        non_glob_search = ( search.match( /^([^\*\?]*)/ ) )[ 1 ]
+      @installable_headers.reduce([]) do |memo, search|
+        non_glob_search = (search.match(/^([^\*\?]*)/))[1]
         case
-        when ( non_glob_search !~ /#{ @rakefile_path }/ )
+        when search.start_with?('/'), search.start_with?('..')
           # Skip paths that are not inside the project
-        when File.file?( search )
-          full_path = Rake::Path.expand_with_root( search, @rakefile_path )
-          memo << { :source_file => search, :relative_path => '' }
-        when File.directory?( search )
-          FileList[ search + '/*.' + @header_file_extension ].each do | pathname |
-            full_path = Rake::Path.expand_with_root( pathname, @rakefile_path )
-            memo << { :source_file => pathname, :relative_path => '' }
+        when File.file?(search)
+          memo << {:source_file => search, :relative_path => ''}
+        when File.directory?(search)
+          FileList[search + '/*.' + @header_file_extension].each do |pathname|
+            memo << {:source_file => pathname, :relative_path => ''}
           end
-        when ( search =~ /[\*\?]/ )
-          FileList[ search ].each do | pathname |
-            full_path = Rake::Path.expand_with_root( pathname, @rakefile_path )
-            directory = File.dirname( full_path )
-            relative  = Rake::Path.relative_path( directory, non_glob_search )
-            memo << { :source_file => pathname, :relative_path => relative }
+        when (search =~ /[\*\?]/)
+          FileList[search].each do |pathname|
+            full_path = Rake::Path.expand_with_root(pathname, @rakefile_path)
+            directory = File.dirname(full_path)
+            relative  = Rake::Path.relative_path(directory, non_glob_search)
+            memo << {:source_file => pathname, :relative_path => relative}
           end
         else
-          $stderr.puts "Bad search path: '${ search }'"
+          $stderr.puts "Bad search path: '#{search}'"
         end
         memo
       end
@@ -550,23 +558,14 @@ module Rake
       end
     end
 
-    def install_file(source_pathname, destination_path)
-      begin
-        shell "cp '#{ source_pathname }' '#{ destination_path }'", Logger::INFO
-      rescue Errno::EACCES => e
-        source_filename = File.basename( source_pathname ) rescue '????'
-        raise Error.new( "You do not have permission to install '#{ source_filename }' to '#{ destination_path }'\nTry\n $ sudo rake install", task_namespace )
-      end
-    end
-
-    def shell(command, log_level = Logger::DEBUG)
+    def shell(command, log_level = ::Logger::DEBUG)
       @logger.add(log_level, command)
       originals        = $stdout, $stderr
       stdout, stderr   = StringIO.new, StringIO.new
       $stdout, $stderr = stdout, stderr
       system command, {:out => :out, :err => :err}
       $stdout, $stderr = *originals
-      [stdout.read, stderr.read]
+      [stdout.string, stderr.string]
     end
   end
 end