rake-builder 0.0.18 → 0.0.19

data/lib/rake/builder/autoconf/version.rb

@@ -0,0 +1,51 @@
+class Rake::Builder
+  class Version
+    def initialize(parameter_version = nil)
+      @parameter_version = parameter_version
+    end
+
+    def decide
+      acceptable_version_string = %r(^(\d+)\.(\d+)\.(\d+)$)
+      if @parameter_version && @parameter_version !~ acceptable_version_string
+        raise "The supplied version number '#{@parameter_version}' is badly formatted. It should consist of three numbers separated by ."
+      end
+      file_version = load_file_version
+      if file_version && file_version !~ acceptable_version_string
+        raise "Your VERSION file contains a version number '#{file_version}' which is badly formatted. It should consist of three numbers separated by ."
+      end
+      case
+      when @parameter_version.nil? && file_version.nil?
+        raise <<-EOT
+        This task requires a project version: major.minor.revision (e.g. 1.03.0567)
+        Please do one of the following:
+        - supply a version parameter: rake autoconf[project_name,version]
+        - create a VERSION file.
+        EOT
+      when file_version.nil?
+        save_file_version @parameter_version
+        return @parameter_version
+      when @parameter_version.nil?
+        return file_version
+      when file_version != @parameter_version
+        raise <<-EOT
+        The version parameter supplied is different to the value in the VERSION file
+        EOT
+      else
+        return file_version
+      end
+    end
+
+    private
+
+    def load_file_version
+      return nil unless File.exist?('VERSION')
+      version = File.read('VERSION')
+      version.strip
+    end
+
+    def save_file_version(version)
+      File.open('VERSION', 'w') { |f| f.write "#{version}\n" }
+    end
+  end
+end
+

data/lib/rake/builder/configure_ac.rb

@@ -0,0 +1,51 @@
+class Rake::Builder
+  class ConfigureAc
+    # source_file - the relative path to any one source file in the project
+    def initialize(project_title, version, source_file)
+      @project_title, @version, @source_file = project_title, version, source_file
+    end
+
+    def to_s
+      <<EOT
+AC_PREREQ(2.61)
+AC_INIT(#{@project_title}, #{@version})
+AC_CONFIG_SRCDIR([#{@source_file}])
+AC_CONFIG_HEADER([config.h])
+AM_INIT_AUTOMAKE([#{@project_title}], [#{@version}])
+
+# Checks for programs.
+AC_PROG_CXX
+AC_PROG_CC
+AC_PROG_RANLIB
+
+# Checks for libraries.
+
+# Checks for header files.
+
+# Checks for typedefs, structures, and compiler characteristics.
+AC_HEADER_STDBOOL
+AC_C_CONST
+AC_C_INLINE
+AC_STRUCT_TM
+
+# Checks for library functions.
+AC_FUNC_LSTAT
+AC_FUNC_LSTAT_FOLLOWS_SLASHED_SYMLINK
+AC_FUNC_MEMCMP
+AC_HEADER_STDC
+AC_CHECK_FUNCS([memset strcasecmp])
+
+AC_CONFIG_FILES([Makefile])
+
+AC_OUTPUT
+EOT
+    end
+
+    def save
+      File.open('configure.ac', 'w') do |f|
+        f.write to_s
+      end
+    end
+  end
+end
+

data/lib/rake/builder/error.rb

@@ -0,0 +1,17 @@
+class Rake::Builder
+  class Error < StandardError
+    attr_accessor :namespace
+
+    def initialize(message, namespace = nil)
+      super(message)
+      @namespace = namespace
+    end
+
+    def to_s
+      message = super
+      message = "#{@namespace}: #{message}" if @namespace
+      message
+    end
+  end
+end
+

data/lib/rake/builder/logger/formatter.rb

@@ -0,0 +1,8 @@
+class Rake::Builder
+  class Formatter < Logger::Formatter
+    def call(severity, time, progname, msg)
+      msg2str(msg) << "\n"
+    end
+  end
+end
+

data/lib/rake/builder/presenters/makefile/builder_presenter.rb

@@ -0,0 +1,75 @@
+module Rake::Builder::Presenters; end
+
+module Rake::Builder::Presenters::Makefile
+  class BuilderPresenter
+    def initialize(builder)
+      @builder = builder
+    end
+
+    def to_s
+      objects      = @builder.object_files.collect { |f| f.sub(@builder.objects_path, '$(OBJECT_DIR)') }
+      objects_list = objects.join( ' ' )
+      case @builder.target_type
+      when :executable
+        target_name = 'EXECUTABLE_TARGET'
+        target_ref  = "$(#{target_name})"
+        target_actions =
+"	$(LINKER) $(LINK_FLAGS) -o #{target_ref} $(OBJECTS)
+"
+      when :static_library
+        target_name = 'LIB_TARGET'
+        target_ref  = "$(#{target_name})"
+        target_actions =
+"	rm -f #{target_ref}
+	ar -cq #{target_ref} $(OBJECTS)
+	ranlib #{target_ref}
+"
+      when :shared_library
+        target_name = 'LIB_TARGET'
+        target_ref  = "$(#{target_name})"
+        target_actions =
+"	$(LINKER) -shared -o #{target_ref} $(OBJECTS) $(LINK_FLAGS)
+"
+      end
+
+      variables = <<EOT
+COMPILER       = #{@builder.compiler}
+COMPILER_FLAGS = #{@builder.compiler_flags}
+LINKER         = #{@builder.linker}
+LINK_FLAGS     = #{@builder.link_flags}
+OBJECT_DIR     = #{@builder.objects_path}
+OBJECTS        = #{objects_list}
+#{ target_name } = #{@builder.target}
+EOT
+      rules = <<EOT
+
+all: #{target_ref}
+
+clean:
+	rm -f $(OBJECTS)
+	rm -f #{target_ref}
+
+#{target_ref}: $(OBJECTS)
+#{target_actions}
+EOT
+
+      source_groups = group_files_by_path(@builder.source_files)
+      source_groups.each.with_index do | gp, i |
+        variables << "SOURCE_#{i + 1} = #{gp[0]}\n"
+        rules     << <<EOT
+
+$(OBJECT_DIR)/%.o: $(SOURCE_#{i + 1})/%.cpp
+	$(COMPILER) -c $(COMPILER_FLAGS) -o $@ $<
+EOT
+      end
+      variables + rules
+    end
+
+    def save
+      File.open(@builder.makefile_name, 'w') do |file|
+        file.write to_s
+      end
+    end
+  end
+end
+

data/lib/rake/builder/presenters/makefile_am/builder_collection_presenter.rb

@@ -10,6 +10,12 @@ module Rake; class Builder; module Presenters; module MakefileAm
       programs_list + program_sections + libraries_list + library_sections
     end
 
+    def save
+      File.open('Makefile.am', 'w') do |f|
+        f.write to_s
+      end
+    end
+
     private
 
     def programs

data/lib/rake/builder/qt_builder.rb

@@ -34,7 +34,7 @@ module Rake
         @framework_paths       = [ '/Library/Frameworks' ]
         @moc_defines           = [ '-D__APPLE__',  '-D__GNUC__' ]
       else
-        raise BuilderError.new( "Unrecognised platform" )
+        raise Error.new( "Unrecognised platform" )
       end
       @compilation_defines   = [ '-DQT_GUI_LIB', '-DQT_CORE_LIB', '-DQT_SHARED' ]
       @resource_files        = []
@@ -42,8 +42,8 @@ module Rake
     end
 
     def configure
-      raise BuilderError.new( 'programming_language must be C++' ) if @programming_language.downcase != 'c++'
-      raise BuilderError.new( 'qt_version must be set' )           if ! @qt_version
+      raise Error.new( 'programming_language must be C++' ) if @programming_language.downcase != 'c++'
+      raise Error.new( 'qt_version must be set' )           if ! @qt_version
 
       super
 

data/lib/rake/builder/task_definer.rb

@@ -0,0 +1,150 @@
+require 'rake/file_task_alias'
+require 'rake/local_config'
+
+include Rake::DSL
+
+class Rake::Builder
+  class TaskDefiner
+    def initialize(builder)
+      @builder = builder
+    end
+
+    def run
+      if @builder.task_namespace
+        namespace @builder.task_namespace do
+          define
+        end
+      else
+        define
+      end
+      define_default
+    end
+
+    private
+
+    def define
+      once_task :environment do
+        @builder.logger.level = Logger::DEBUG if ENV['DEBUG']
+      end
+
+      if @builder.target_type == :executable
+        desc "Run '#{@builder.target_basename}'"
+        task :run => :build do
+          @builder.run
+        end
+      end
+
+      desc "Compile and build '#{@builder.target_basename}'"
+      Rake::FileTaskAlias.define_task(:build, @builder.target)
+
+      desc "Build '#{@builder.target_basename}'"
+      microsecond_file @builder.target => [
+        scoped_task(:environment),
+        scoped_task(:compile),
+        *@builder.target_prerequisites
+      ] do
+        @builder.build
+      end
+
+      desc "Compile all sources"
+      # Only import dependencies when we're compiling
+      # otherwise makedepend gets run on e.g. 'rake -T'
+      once_task :compile => [
+        scoped_task(:environment),
+        @builder.makedepend_file,
+        scoped_task(:load_makedepend),
+        *@builder.object_files
+      ]
+
+      @builder.source_files.each do |src|
+        define_compile_task(src)
+      end
+
+      # TODO: Does this need to be microsecond?
+      microsecond_directory @builder.objects_path
+
+      file scoped_task(@builder.local_config) do
+        @builder.create_local_config
+      end
+
+      microsecond_file @builder.makedepend_file => [
+          scoped_task(:load_local_config),
+          scoped_task(:missing_headers),
+          @builder.objects_path,
+          *@builder.project_files
+      ] do
+        @builder.create_makedepend_file
+      end
+
+      once_task scoped_task(:load_local_config) => scoped_task(@builder.local_config) do
+        @builder.load_local_config
+      end
+
+      once_task scoped_task(:missing_headers) => [*@builder.generated_headers] do
+        @builder.missing_headers
+      end
+
+      # Reimplemented mkdepend file loading to make objects depend on
+      # sources with the correct paths:
+      # the standard rake mkdepend loader doesn't do what we want,
+      # as it assumes files will be compiled in their own directory.
+      task :load_makedepend => @builder.makedepend_file do
+        @builder.load_makedepend
+      end
+
+      desc "List generated files (which are removed with 'rake #{scoped_task(:clean)}')"
+      task :generated_files do
+        puts @builder.generated_files.to_json
+      end
+
+      # Re-implement :clean locally for project and within namespace
+      # Standard :clean is a singleton
+      desc "Remove temporary files"
+      task :clean do
+        @builder.clean
+      end
+
+      desc "Install '#{@builder.target_basename}' in '#{@builder.install_path}'"
+      task :install, [] => [scoped_task(:build)] do
+        @builder.install
+      end
+
+      desc "Uninstall '#{@builder.target_basename}' from '#{@builder.install_path}'"
+      task :uninstall, [] => [] do
+        @builder.uninstall
+      end
+
+      desc "Create a '#{@builder.makefile_name}' to build the project"
+      file "#{@builder.makefile_name}" => [@builder.makedepend_file, scoped_task(:load_makedepend)] do
+        Rake::Builder::Presenters::Makefile::BuilderPresenter.new(@builder).save
+      end
+    end
+
+    def define_default
+      name = scoped_task(@builder.default_task)
+      desc "Equivalent to 'rake #{name}'"
+      if @builder.task_namespace
+        task @builder.task_namespace => [name]
+      else
+        task :default => [name]
+      end
+    end
+
+    def define_compile_task(source)
+      object = @builder.object_path(source)
+      @builder.generated_files << object
+      file object => [ source ] do |t|
+        @builder.compile(source, object)
+      end
+    end
+
+    def scoped_task(task)
+      if @builder.task_namespace
+        "#{@builder.task_namespace}:#{task}"
+      else
+        task
+      end
+    end
+  end
+end
+

data/lib/rake/builder/version.rb

@@ -6,7 +6,7 @@ module Rake
     module VERSION #:nodoc:
       MAJOR = 0
       MINOR = 0
-      TINY  = 18
+      TINY  = 19
 
       STRING = [ MAJOR, MINOR, TINY ].join('.')
     end

data/lib/rake/builder.rb

@@ -3,11 +3,15 @@ require 'logger'
 require 'rake'
 require 'rake/tasklib'
 
+require 'rake/builder/autoconf/version'
+require 'rake/builder/configure_ac'
+require 'rake/builder/error'
+require 'rake/builder/logger/formatter'
+require 'rake/builder/presenters/makefile/builder_presenter'
 require 'rake/builder/presenters/makefile_am/builder_presenter'
 require 'rake/builder/presenters/makefile_am/builder_collection_presenter'
+require 'rake/builder/task_definer'
 require 'rake/path'
-require 'rake/local_config'
-require 'rake/file_task_alias'
 require 'rake/microsecond'
 require 'rake/once_task'
 require 'compiler'
@@ -15,33 +19,9 @@ require 'compiler'
 include Rake::DSL
 
 module Rake
-
-  class Formatter < Logger::Formatter
-    def call(severity, time, progname, msg)
-      msg2str(msg) << "\n"
-    end
-  end
-
-  class Builder < TaskLib
-
-    class BuilderError < StandardError
-      attr_accessor :namespace
-
-      def initialize( message, namespace = nil )
-        super( message )
-        @namespace = namespace
-      end
-
-      def to_s
-        message = super
-        message = "#{ @namespace }: #{ message }" if @namespace
-        message
-      end
-    end
-
+  class Builder
     # Error indicating that the project failed to build.
-    class BuildFailure < BuilderError
-    end
+    class BuildFailure < Error; end
 
     # The file to be built
     attr_accessor :target
@@ -57,6 +37,8 @@ module Rake
     # processor type: 'i386', 'x86_64', 'ppc' or 'ppc64'.
     attr_accessor :architecture
 
+    attr_accessor :compiler_data
+
     # The programming language: 'c++', 'c' or 'objective-c' (default 'c++')
     # This also sets defaults for source_file_extension
     attr_accessor :programming_language
@@ -182,122 +164,125 @@ module Rake
       @instances
     end
 
-    def self.define_global
-      desc "Create input files for configure script creation"
-      task :autoconf, [:project_title, :version] => [] do | task, args |
-        project_title = args.project_title or raise "Please supply a project_title parameter"
-        version       = decide_version( args.version )
-        if File.exist?('configure.ac')
-          raise "The file 'configure.ac' already exists"
-        end
-        if File.exist?('Makefile.am')
-          raise "The file 'Makefile.am' already exists"
-        end
-        create_configure_ac project_title, version
-        create_makefile_am
+    def self.create_autoconf(project_title, version, source_file)
+      raise "Please supply a project_title parameter" if project_title.nil?
+      version = Rake::Builder::Version.new(version).decide
+      if File.exist?('configure.ac')
+        raise "The file 'configure.ac' already exists"
       end
+      if File.exist?('Makefile.am')
+        raise "The file 'Makefile.am' already exists"
+      end
+      ConfigureAc.new(project_title, version, source_file).save
+      Presenters::MakefileAm::BuilderCollectionPresenter.new(instances).save
+    end
+ 
+    desc "Create input files for configure script creation"
+    task :autoconf, [:project_title, :version] => [] do |task, args|
+      source = Rake::Path.relative_path(instances[0].source_files[0], instances[0].rakefile_path)
+      create_autoconf(args.project_title, args.version, source)
     end
 
-    def self.create_configure_ac( project_title, version )
-      source = Rake::Path.relative_path( instances[ 0 ].source_files[ 0 ], instances[ 0 ].rakefile_path  )
-      File.open('configure.ac', 'w') do | f |
-        f.write <<EOT
-AC_PREREQ(2.61)
-AC_INIT(#{project_title}, #{ version })
-AC_CONFIG_SRCDIR([#{ source }])
-AC_CONFIG_HEADER([config.h])
-AM_INIT_AUTOMAKE([#{project_title}], [#{ version }])
-
-# Checks for programs.
-AC_PROG_CXX
-AC_PROG_CC
-AC_PROG_RANLIB
+    def initialize( &block )
+      save_rakefile_info( block )
+      set_defaults
+      block.call( self )
+      configure
+      TaskDefiner.new(self).run
+      self.class.instances << self
+    end
 
-# Checks for libraries.
+    def run
+      command = "cd #{rakefile_path} && #{target}"
+      puts shell(command, Logger::INFO)
+    end
 
-# Checks for header files.
+    def build
+      system "rm -f #{target}"
+      build_commands.each do |command|
+        stdout, stderr = shell(command)
+        raise BuildFailure.new("Error: command '#{command}' failed: #{stderr} #{stdout}") if not $?.success?
+      end
+      raise BuildFailure.new("'#{target}' not created") if not File.exist?(target)
+    end
 
-# Checks for typedefs, structures, and compiler characteristics.
-AC_HEADER_STDBOOL
-AC_C_CONST
-AC_C_INLINE
-AC_STRUCT_TM
+    def create_local_config
+      logger.add(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
+    end
 
-# Checks for library functions.
-AC_FUNC_LSTAT
-AC_FUNC_LSTAT_FOLLOWS_SLASHED_SYMLINK
-AC_FUNC_MEMCMP
-AC_HEADER_STDC
-AC_CHECK_FUNCS([memset strcasecmp])
+    def create_makedepend_file
+      system('which makedepend >/dev/null')
+      raise 'makedepend not found' unless $?.success?
+      logger.add(Logger::DEBUG, "Analysing dependencies")
+      command = "makedepend -f- -- #{include_path} -- #{file_list(source_files)} 2>/dev/null > #{makedepend_file}"
+      shell command
+    end
 
-AC_CONFIG_FILES([Makefile])
+    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
 
-AC_OUTPUT
-EOT
+    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
+      end
+      File.open(makedepend_file).each_line do |line|
+        next if line !~ /:\s/
+        mapped_object_file = $`
+        header_files = $'.chomp
+        # TODO: Why does it work,
+        # if I make the object (not the source) depend on the header?
+        source_file = object_to_source[mapped_object_file]
+        object_file = object_path(source_file)
+        object_file_task = Rake.application[object_file]
+        object_file_task.enhance(header_files.split(' '))
       end
     end
 
-    def self.create_makefile_am
-      presenter = Rake::Builder::Presenters::MakefileAm::BuilderCollectionPresenter.new(instances)
-      File.open('Makefile.am', 'w') do |f|
-        f.write presenter.to_s
+    def clean
+      generated_files.each do |file|
+        system "rm -f #{file}"
       end
     end
 
-    #########################################
-    # VERSION file
+    def install
+      destination = File.join(install_path, target_basename)
+      install_file(target, destination)
+      install_headers if target_type == :static_library
+    end
 
-    def self.decide_version( parameter_version )
-      acceptable_version_string = %r(^(\d+)\.(\d+)\.(\d+)$)
-      if parameter_version && parameter_version !~ acceptable_version_string
-        raise "The supplied version number '#{parameter_version}' is badly formatted. It should consist of three numbers separated by ."
+    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
-      file_version = load_file_version
-      if file_version && file_version !~ acceptable_version_string
-        raise "Your VERSION file contains a version number '#{file_version}' which is badly formatted. It should consist of three numbers separated by ."
-      end
-      case
-      when parameter_version.nil? && file_version.nil?
-        raise <<-EOT
-        This task requires a project version: major.minor.revision (e.g. 1.03.0567)
-        Please do one of the following:
-        - supply a version parameter: rake autoconf[project_name,version]
-        - create a VERSION file.
-        EOT
-      when file_version.nil?
-        save_file_version parameter_version
-        return parameter_version
-      when parameter_version.nil?
-        return file_version
-      when file_version != parameter_version
-        raise <<-EOT
-        The version parameter supplied is different to the value in the VERSION file
-        EOT
-      else
-        return file_version
+      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
     end
 
-    def self.load_file_version
-      return nil unless File.exist?('VERSION')
-      version = File.read('VERSION')
-      version.strip
-    end
-
-    def self.save_file_version( version )
-      File.open('VERSION', 'w') { |f| f.write "#{version}\n" }
+    def compile(source, object)
+      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
- 
-    self.define_global
 
-    def initialize( &block )
-      save_rakefile_info( block )
-      initialize_attributes
-      block.call( self )
-      configure
-      define_tasks
-      define_default
-      self.class.instances << self
+    # TODO: make private
+    def file_list( files, delimiter = ' ' )
+      files.join( delimiter )
     end
 
     # Source files found in source_search_paths
@@ -328,9 +313,18 @@ EOT
       source_files.map{ |file| Rake::Path.relative_path(file, rakefile_path) }
     end
 
+    def object_files
+      source_files.map { |file| object_path(file) }
+    end
+
+    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)
+    end
+
     def compiler_flags
       flags = include_path
-      options = compilation_options.join( ' ' )
+      options = compilation_options.join(' ')
       flags << ' ' + options             if options != ''
       flags << ' ' + architecture_option if RUBY_PLATFORM =~ /darwin/i
       flags
@@ -340,12 +334,42 @@ EOT
       @library_dependencies.map { |lib| "-l#{ lib }"}.join('')
     end
 
+    def target_basename
+      File.basename(@target)
+    end
+
+    def makefile_name
+      extension = if ! task_namespace.nil? && ! task_namespace.to_s.empty?
+                    '.' + task_namespace.to_s
+                  else
+                    ''
+                  end
+      "Makefile#{ extension }"
+    end
+
+    def project_files
+      source_files + header_files
+    end
+
+    def generated_headers
+      []
+    end
+
+    # Discovery
+
+    def missing_headers
+      return @missing_headers if @missing_headers
+      default_includes = @compiler_data.default_include_paths( @programming_language )
+      all_includes     = default_includes + @include_paths
+      @missing_headers = @compiler_data.missing_headers( all_includes, source_files )
+    end
+
     private
 
-    def initialize_attributes
+    def set_defaults
       @architecture          = 'i386'
-      @compiler_data         = Compiler::Base.for( :gcc )
-      @logger                = Logger.new( STDOUT )
+      @compiler_data         = Compiler::Base.for(:gcc)
+      @logger                = Logger.new(STDOUT)
       @logger.level          = Logger::UNKNOWN
       @logger.formatter      = Formatter.new
       @programming_language  = 'c++'
@@ -354,8 +378,8 @@ EOT
       @library_paths         = []
       @library_dependencies  = []
       @target_prerequisites  = []
-      @source_search_paths   = [ @rakefile_path.dup ]
-      @header_search_paths   = [ @rakefile_path.dup ]
+      @source_search_paths   = [@rakefile_path.dup]
+      @header_search_paths   = [@rakefile_path.dup]
       @target                = 'a.out'
       @generated_files       = []
       @compilation_options   = []
@@ -363,11 +387,11 @@ EOT
     end
 
     def configure
-      @compilation_options   += [ architecture_option ] if RUBY_PLATFORM =~ /apple/i
+      @compilation_options   += [architecture_option] if RUBY_PLATFORM =~ /apple/i
       @compilation_options.uniq!
 
       @programming_language = @programming_language.to_s.downcase
-      raise BuilderError.new( "Don't know how to build '#{ @programming_language }' programs", task_namespace ) if KNOWN_LANGUAGES[ @programming_language ].nil?
+      raise Error.new( "Don't know how to build '#{ @programming_language }' programs", task_namespace ) if KNOWN_LANGUAGES[ @programming_language ].nil?
       @compiler              ||= KNOWN_LANGUAGES[ @programming_language ][ :compiler ]
       @linker                ||= KNOWN_LANGUAGES[ @programming_language ][ :linker ]
       @ar                    ||= KNOWN_LANGUAGES[ @programming_language ][ :ar ]
@@ -378,12 +402,14 @@ EOT
       @header_search_paths   = Rake::Path.expand_all_with_root( @header_search_paths, @rakefile_path )
       @library_paths         = Rake::Path.expand_all_with_root( @library_paths, @rakefile_path )
 
-      raise BuilderError.new( "The target name cannot be nil", task_namespace )             if @target.nil?
-      raise BuilderError.new( "The target name cannot be an empty string", task_namespace ) if @target == ''
+      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 BuilderError.new( "Building #{ @target_type } targets is not supported", task_namespace ) if ! TARGET_TYPES.include?( @target_type )
+      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 )
 
@@ -397,264 +423,9 @@ EOT
       @local_config          = Rake::Path.expand_with_root( '.rake-builder', @rakefile_path )
 
       @makedepend_file       = @objects_path + '/.' + target_basename + '.depend.mf'
-
-      raise BuilderError.new( "No source files found", task_namespace ) if source_files.length == 0
-    end
-
-    def define_tasks
-      if @task_namespace
-        namespace @task_namespace do
-          define
-        end
-      else
-        define
-      end
-    end
-
-    def define_default
-      name = scoped_task( @default_task )
-      desc "Equivalent to 'rake #{ name }'"
-      if @task_namespace
-        task @task_namespace => [ name ]
-      else
-        task :default => [ name ]
-      end
-    end
-
-    def define
-      once_task :environment do
-        logger.level = Logger::DEBUG if ENV[ 'DEBUG' ]
-      end
-
-      if @target_type == :executable
-        desc "Run '#{ target_basename }'"
-        task :run => :build do
-          command = "cd #{ @rakefile_path } && #{ @target }"
-          puts shell( command, Logger::INFO )
-        end
-      end
-
-      desc "Compile and build '#{ target_basename }'"
-      FileTaskAlias.define_task( :build, @target )
-
-      desc "Build '#{ target_basename }'"
-      microsecond_file @target => [ scoped_task( :environment ),
-                        scoped_task( :compile ),
-                        *@target_prerequisites ] do | t |
-        shell "rm -f #{ t.name }"
-        build_commands.each do | command |
-          stdout, stderr = shell(command)
-          raise BuildFailure.new("Error: command '#{command}' failed: #{stderr} #{stdout}") if not $?.success?
-        end
-        raise BuildFailure.new("'#{@target}' not created") if not File.exist?(@target)
-      end
-
-      desc "Compile all sources"
-      # Only import dependencies when we're compiling
-      # otherwise makedepend gets run on e.g. 'rake -T'
-      once_task :compile => [ scoped_task( :environment ),
-                         @makedepend_file,
-                         scoped_task( :load_makedepend ),
-                         *object_files ]
-
-      source_files.each do |src|
-        define_compile_task( src )
-      end
-
-      microsecond_directory @objects_path
-
-      file scoped_task( local_config ) do
-        @logger.add( 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
-      end
-
-      microsecond_file @makedepend_file => [
-          scoped_task( :load_local_config ),
-          scoped_task( :missing_headers ),
-          @objects_path,
-          *project_files
-      ] do
-        system('which makedepend >/dev/null')
-        raise 'makedepend not found' unless $?.success?
-        @logger.add( Logger::DEBUG, "Analysing dependencies" )
-        command = "makedepend -f- -- #{ include_path } -- #{ file_list( source_files ) } 2>/dev/null > #{ @makedepend_file }"
-        shell command
-      end
-
-      once_task scoped_task( :load_local_config ) => scoped_task( local_config ) do
-        config = 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
-
-      once_task scoped_task( :missing_headers ) => [ *generated_headers ] do
-        missing_headers
-      end
-
-      # Reimplemented mkdepend file loading to make objects depend on
-      # sources with the correct paths:
-      # the standard rake mkdepend loader doesn't do what we want,
-      # as it assumes files will be compiled in their own directory.
-      task :load_makedepend => @makedepend_file do
-        object_to_source = source_files.inject( {} ) do | memo, source |
-          mapped_object = source.gsub( '.' + @source_file_extension, '.o' )
-          memo[ mapped_object ] = source
-          memo
-        end
-        File.open( @makedepend_file ).each_line do |line|
-          next if line !~ /:\s/
-          mapped_object_file = $`
-          header_files = $'.chomp
-          # TODO: Why does it work,
-          # if I make the object (not the source) depend on the header?
-          source_file = object_to_source[ mapped_object_file ]
-          object_file = object_path( source_file )
-          object_file_task = Rake.application[ object_file ]
-          object_file_task.enhance(header_files.split(' '))
-        end
-      end
-
-      desc "List generated files (which are removed with 'rake #{ scoped_task( :clean ) }')"
-      task :generated_files do
-        puts generated_files.to_json
-      end
-
-      # Re-implement :clean locally for project and within namespace
-      # Standard :clean is a singleton
-      desc "Remove temporary files"
-      task :clean do
-        generated_files.each do |file|
-          shell "rm -f #{ file }"
-        end
-      end
-
-      @generated_files << @target
       @generated_files << @makedepend_file
 
-      desc "Install '#{ target_basename }' in '#{ @install_path }'"
-      task :install, [] => [ scoped_task( :build ) ] do
-        destination = File.join( @install_path, target_basename )
-        install( @target, destination )
-        install_headers if @target_type == :static_library
-      end
-
-      desc "Uninstall '#{ target_basename }' from '#{ @install_path }'"
-      task :uninstall, [] => [] do
-        destination = File.join( @install_path, target_basename )
-        if ! File.exist?( destination )
-          @logger.add( Logger::INFO, "The file '#{ destination }' does not exist" )
-          next
-        end
-        begin
-          shell "rm '#{ destination }'", Logger::INFO
-        rescue Errno::EACCES => e
-          raise BuilderError.new( "You do not have permission to uninstall '#{ destination }'\nTry\n $ sudo rake #{ scoped_task( :uninstall ) }", task_namespace )
-        end
-      end
-
-      desc "Create a '#{ makefile_name }' to build the project"
-      file "#{ makefile_name }" => [ @makedepend_file, scoped_task( :load_makedepend ) ] do | t |
-        objects       = object_files.collect { | f | f.sub( "#{ @objects_path }", '$(OBJECT_DIR)' ) }
-        objects_list  = objects.join( ' ' )
-        case @target_type
-        when :executable
-          target_name = 'EXECUTABLE_TARGET'
-          target_ref  = "$(#{ target_name })"
-          target_actions =
-"	$(LINKER) $(LINK_FLAGS) -o #{ target_ref } $(OBJECTS)
-"
-        when :static_library
-          target_name = 'LIB_TARGET'
-          target_ref  = "$(#{ target_name })"
-          target_actions =
-"	rm -f #{ target_ref }
-	ar -cq #{ target_ref } $(OBJECTS)
-	ranlib #{ target_ref }
-"
-        when :shared_library
-          target_name = 'LIB_TARGET'
-          target_ref  = "$(#{ target_name })"
-          target_actions =
-"	$(LINKER) -shared -o #{ target_ref } $(OBJECTS) $(LINK_FLAGS)
-"
-        end
-
-        variables = <<EOT
-COMPILER       = #{ @compiler }
-COMPILER_FLAGS = #{ compiler_flags }
-LINKER         = #{ @linker }
-LINK_FLAGS     = #{ link_flags }
-OBJECT_DIR     = #{ @objects_path }
-OBJECTS        = #{ objects_list }
-#{ target_name } = #{ @target }
-EOT
-        rules     = <<EOT
-
-all: #{ target_ref }
-
-clean:
-	rm -f $(OBJECTS)
-	rm -f #{ target_ref }
-
-#{ target_ref }: $(OBJECTS)
-#{ target_actions }
-EOT
-
-        source_groups = group_files_by_path( source_files )
-        source_groups.each.with_index do | gp, i |
-          variables << "SOURCE_#{ i + 1 } = #{ gp[ 0 ] }\n"
-          rules     << <<EOT
-
-$(OBJECT_DIR)/%.o: $(SOURCE_#{ i + 1 })/%.cpp
-	$(COMPILER) -c $(COMPILER_FLAGS) -o $@ $<
-EOT
-        end
-
-        File.open( t.name, 'w' ) do | file |
-          file.write variables
-          file.write rules
-        end
-      end
-
-    end
-
-    def generated_headers
-      []
-    end
-
-    def scoped_task( task )
-      if @task_namespace
-        "#{ task_namespace }:#{ task }"
-      else
-        task
-      end
-    end
-
-    def define_compile_task( source )
-      object = object_path( source )
-      @generated_files << object
-      file object => [ source ] do |t|
-        @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
-    end
-
-    def build_commands
-      case @target_type
-      when :executable
-        [ "#{ @linker } -o #{ @target } #{ file_list( object_files ) } #{ link_flags }" ]
-      when :static_library
-        [ "#{ @ar } -cq #{ @target } #{ file_list( object_files ) }",
-          "#{ @ranlib } #{ @target }" ]
-      when :shared_library
-        [ "#{ @linker } -shared -o #{ @target } #{ file_list( object_files ) } #{ link_flags }" ]
-      end
+      raise Error.new( "No source files found", task_namespace ) if source_files.length == 0
     end
 
     def to_target_type(target)
@@ -668,15 +439,6 @@ EOT
       end
     end
 
-    # Discovery
-
-    def missing_headers
-      return @missing_headers if @missing_headers
-      default_includes = @compiler_data.default_include_paths( @programming_language )
-      all_includes     = default_includes + @include_paths
-      @missing_headers = @compiler_data.missing_headers( all_includes, source_files )
-    end
-
     # Compiling and linking parameters
 
     def include_path
@@ -707,11 +469,6 @@ EOT
       @rakefile_path = File.dirname( @rakefile )
     end
 
-    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 )
-    end
-
     def default_install_path( target_type )
       case target_type
       when :executable
@@ -730,39 +487,12 @@ EOT
 
     # Files
 
-    def target_basename
-      File.basename( @target )
-    end
-
-    def makefile_name
-      extension = if ! task_namespace.nil? && ! task_namespace.to_s.empty?
-                    '.' + task_namespace.to_s
-                  else
-                    ''
-                  end
-      "Makefile#{ extension }"
-    end
-
     # Lists of files
 
     def find_files( paths, extension )
       files = Rake::Path.find_files( paths, extension )
       Rake::Path.expand_all_with_root( files, @rakefile_path )
     end
-
-    # TODO: make this return a FileList, not a plain Array
-    def object_files
-      source_files.map { |file| object_path( file ) }
-    end
-
-    def project_files
-      source_files + header_files
-    end
-    public :project_files
-
-    def file_list( files, delimiter = ' ' )
-      files.join( delimiter )
-    end
     
     def library_paths_list
       @library_paths.map { | path | "-L#{ path }" }.join( " " )
@@ -777,9 +507,9 @@ EOT
         begin
           `mkdir -p '#{ destination_path }'`
         rescue Errno::EACCES => e
-          raise BuilderError.new( "Permission denied to created directory '#{ destination_path }'", task_namespace )
+          raise Error.new( "Permission denied to created directory '#{ destination_path }'", task_namespace )
         end
-        install( installable_header[ :source_file ], destination_path )
+        install_file( installable_header[ :source_file ], destination_path )
       end
     end
 
@@ -811,12 +541,26 @@ EOT
       end
     end
 
-    def install( source_pathname, destination_path )
+    def build_commands
+      case target_type
+      when :executable
+        [ "#{ linker } -o #{ target } #{ file_list( object_files ) } #{ link_flags }" ]
+      when :static_library
+        [ "#{ ar } -cq #{ target } #{ file_list( object_files ) }",
+          "#{ ranlib } #{ target }" ]
+      when :shared_library
+        [ "#{ linker } -shared -o #{ target } #{ file_list( object_files ) } #{ link_flags }" ]
+      else
+        # TODO: raise an error
+      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 BuilderError.new( "You do not have permission to install '#{ source_filename }' to '#{ destination_path }'\nTry\n $ sudo rake install", task_namespace )
+        raise Error.new( "You do not have permission to install '#{ source_filename }' to '#{ destination_path }'\nTry\n $ sudo rake install", task_namespace )
       end
     end
 
@@ -829,8 +573,6 @@ EOT
       $stdout, $stderr = *originals
       [stdout.read, stderr.read]
     end
-
   end
-
 end
 

data/lib/rake/local_config.rb

@@ -22,7 +22,7 @@ module Rake
       @include_paths       = config[:include_paths]
       @compilation_options = config[:compilation_options]
       if not VERSIONS.find_index(version)
-        raise Rake::Builder::BuilderError.new('Config file version incorrect') 
+        raise Rake::Builder::Error.new('Config file version incorrect') 
       end
     end
 

data/spec/autoconf_spec.rb

@@ -5,9 +5,6 @@ describe 'autoconf' do
   include RakeBuilderHelper
 
   before :each do
-    Rake::Task.clear
-    Rake::Builder.define_global
-
     @project = cpp_task(:executable)
 
     @args = Rake::TaskArguments.new(
@@ -160,11 +157,10 @@ describe 'autoconf' do
 
   context 'Makefile.am' do
     it 'is created' do
-      Rake::Builder.should_receive(:create_makefile_am)
+      Rake::Builder.should_receive(:create_autoconf)
 
       Rake::Task['autoconf'].execute(@args)
     end
   end
-
 end
 

data/spec/local_config_spec.rb

@@ -36,7 +36,7 @@ describe 'local config files' do
     lambda do
       config = Rake::LocalConfig.new( @local_config_file )
       config.load
-    end.should raise_error( Rake::Builder::BuilderError, 'Config file version incorrect' )
+    end.should raise_error(Rake::Builder::Error, 'Config file version incorrect')
   end
 
   context 'dependencies' do

data/spec/target_spec.rb

@@ -16,7 +16,7 @@ describe 'when creating tasks' do
         builder.target = ''
         builder.source_search_paths = [ 'cpp_project' ]
       end
-    end.should raise_error( Rake::Builder::BuilderError, 'The target name cannot be an empty string' )
+    end.should raise_error(Rake::Builder::Error, 'The target name cannot be an empty string')
   end
 
   it 'raises an error when the target is set to nil' do
@@ -25,7 +25,7 @@ describe 'when creating tasks' do
         builder.target = nil
         builder.source_search_paths = [ 'cpp_project' ]
       end
-    end.should raise_error( Rake::Builder::BuilderError, 'The target name cannot be nil' )
+    end.should raise_error(Rake::Builder::Error, 'The target name cannot be nil')
   end
 
   it 'sets the target to \'a.out\' if it is not set' do

data/spec/unit/rake/builder_spec.rb

@@ -1,28 +1,51 @@
 require 'spec_helper'
 
 describe Rake::Builder do
-  context '.create_makefile_am' do
-    let(:presenter) { stub('Rake::Builder::Presenters::MakefileAm::BuilderCollectionPresenter', :to_s => 'contents') }
+  context '.create_autoconf' do
+    let(:version) { stub('Rake::Builder::Autoconf::Version', :decide => 'qux') }
+    let(:presenter) { stub('Rake::Builder::Presenters::MakefileAm::BuilderCollectionPresenter', :save => nil) }
+    let(:configure_ac) { stub('Rake::Builder::ConfigureAc', :save => nil) }
 
     before do
+      Rake::Builder::Version.stub(:new).and_return(version)
+      File.stub(:exist?).with('configure.ac').and_return(false)
+      File.stub(:exist?).with('Makefile.am').and_return(false)
+      Rake::Builder::ConfigureAc.stub(:new => configure_ac)
       Rake::Builder::Presenters::MakefileAm::BuilderCollectionPresenter.stub(:new).and_return(presenter)
-      File.stub(:open).with('Makefile.am', 'w')
     end
 
-    it 'uses the presenter' do
-      Rake::Builder::Presenters::MakefileAm::BuilderCollectionPresenter.should_receive(:new).and_return(presenter)
+    it 'fails if project_title is nil' do
+      expect {
+        Rake::Builder.create_autoconf(nil, 'bar', 'baz')
+      }.to raise_error(RuntimeError, 'Please supply a project_title parameter')
+    end
+
+    it 'fails if configure.ac exists' do
+      File.should_receive(:exist?).with('configure.ac').and_return(true)
+
+      expect {
+        Rake::Builder.create_autoconf('foo', 'bar', 'baz')
+      }.to raise_error(RuntimeError, "The file 'configure.ac' already exists")
+    end
 
-      Rake::Builder.create_makefile_am
+    it 'fails if Makefile.am exists' do
+      File.should_receive(:exist?).with('Makefile.am').and_return(true)
+
+      expect {
+        Rake::Builder.create_autoconf('foo', 'bar', 'baz')
+      }.to raise_error(RuntimeError, "The file 'Makefile.am' already exists")
     end
 
-    it 'writes Makefile.am' do
-      file = stub('File')
-      file.should_receive(:write).with('contents')
-      File.should_receive(:open).with('Makefile.am', 'w') do |&block|
-        block.call file
-      end
+    it 'creates configure.ac' do
+      Rake::Builder::ConfigureAc.should_receive(:new).and_return(configure_ac)
+
+      Rake::Builder.create_autoconf('foo', 'bar', 'baz')
+    end
+
+    it 'creates Makefile.am' do
+      Rake::Builder::Presenters::MakefileAm::BuilderCollectionPresenter.should_receive(:new).and_return(presenter)
 
-      Rake::Builder.create_makefile_am
+      Rake::Builder.create_autoconf('foo', 'bar', 'baz')
     end
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rake-builder
 version: !ruby/object:Gem::Version
-  version: 0.0.18
+  version: 0.0.19
   prerelease: 
 platform: ruby
 authors:
@@ -90,10 +90,16 @@ files:
 - lib/rake/once_task.rb
 - lib/rake/microsecond.rb
 - lib/rake/file_task_alias.rb
+- lib/rake/builder/logger/formatter.rb
 - lib/rake/builder/qt_builder.rb
+- lib/rake/builder/error.rb
 - lib/rake/builder/version.rb
+- lib/rake/builder/task_definer.rb
+- lib/rake/builder/autoconf/version.rb
 - lib/rake/builder/presenters/makefile_am/builder_presenter.rb
 - lib/rake/builder/presenters/makefile_am/builder_collection_presenter.rb
+- lib/rake/builder/presenters/makefile/builder_presenter.rb
+- lib/rake/builder/configure_ac.rb
 - lib/rake/local_config.rb
 - lib/rake/path.rb
 - lib/rake/builder.rb
@@ -165,7 +171,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4521436096979884439
+      hash: 1943333437698493637
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -174,7 +180,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -4521436096979884439
+      hash: 1943333437698493637
 requirements: []
 rubyforge_project: nowarning
 rubygems_version: 1.8.23