bake 0.1.1 → 0.1.2

data/lib/bake/plugins/cpp/qt.rb

@@ -5,42 +5,45 @@ module Bake
     module Plugins
         module Cpp
             module Qt
-                class Moc
-                    include Toolset
+                class Moc < Toolset
+                    def initialize(sys)
+                        super
+                        command(:moc)
+                    end
 
-                    def build(target)
-                        raise "unknown target '#{target}'" if !target.is_a?(MocFile)
-                        return if !stale?(target)
-                        src = target.src
-                        sh("moc -o #{target.output} #{target.src}")
+                    def moc(context, *srcs)
+                        return srcs.collect do |src|
+                            file_target = FileTarget.new(
+                                context.current, toolset, src)
+                            MocFile.new(context.current, self, file_target)
+                        end
                     end
 
-                    def clean(target)
-                        FileUtils.rm_f(target.output)
+                    def build(target)
+                        if !target.is_a?(MocFile)
+                            raise "unknown target '#{target}'"
+                        end
+                        src = target.src
+                        sys.sh("moc -o #{target.path} #{target.src}")
                     end
+                end
 
-                    def stale?(target)
-                        return true if !File.exists?(target.output)
-                        return File.mtime(target.src) > File.mtime(target.output)
+                class MocFile < Source
+                    def src
+                        return @source.path
                     end
 
-                    def sh(*args)
-                        cmd = args.join(' ')
-                        puts cmd
-                        system(*args)
-                        raise "error: #{cmd}" if !$? || !$?.success?
+                    def path
+                        src = @source.path
+                        ext = File.extname(src)
+                        basename = File.basename(src, ext) + '.moc' + ext
+                        return File.join(get(:outdir), basename)
                     end
-                end
 
-                class MocFile < Bake::Target
-                    attr_reader :output
-                    attr_accessor :src
+                    alias :products :path
 
-                    def initialize(parent, src)
-                        super(parent)
-                        ext = File.extname(src)
-                        @output = File.basename(src, ext) + '.moc' + ext
-                        @src = src
+                    def build
+                        toolset.build(self)
                     end
                 end
             end

data/lib/bake/plugins/cpp/toolset_base.rb

@@ -5,76 +5,41 @@ require 'set'
 module Bake
     module Plugins
         module Cpp
-            class ToolsetBase
-                include Toolset
-
-                def initialize
-                    constructor :syslib, SystemLibrary
-                    constructor :lib, Library
-                    constructor :exe, Executable
-                    constructor :run, Runner
+            class ToolsetBase < Toolset
+                module Object
+                    def products
+                        return toolset.obj_fn(self)
+                    end
                 end
 
-                def build(target)
-                    if stale?(target)
-                        FileUtils.mkdir_p(target[:outdir])
-                        if target.is_a?(Cpp::Object)
-                            compile(target)
-                            # refresh the .includes file
-                            includes = target.includes
-                            filename = "#{target[:outdir]}/#{target.src.basename}.includes"
-                            File.open(filename, "w") do |file|
-                                includes.each { |inc| file.puts(inc) }
-                            end
-                        elsif target.is_a?(Cpp::Library)
-                            ar(target)
-                        elsif target.is_a?(Cpp::Executable)
-                            link(target)
-                        elsif target.is_a?(Cpp::Runner)
-                            run(target)
-                        else
-                            raise "unknown Cpp target of class '#{target.class}"
-                        end
+                module Library
+                    def products
+                        return toolset.lib_fn(self)
                     end
                 end
-                
-                def stale?(target)
-                    t = Time.now
-                    output_files(target).each do |out|
-                        return true if !File.exists?(out)
-                        out_time = File.mtime(out)
-                        t = out_time if out_time < t
-                    end
-                    if target.is_a?(Cpp::Object)
-                        return true if File.mtime(target.src) > t
-                        target.includes.each { |file| return true if File.mtime(file) > t }
-                    elsif target.is_a?(Cpp::Runner)
-                        return File.mtime(output_files(target.deps[0])[0]) > t
-                    else
-                        is_linked = target.is_a?(Cpp::Executable) ||
-                            (target.is_a?(Cpp::Library) && target[:libtype] == 'dynamic')
-                        target.children.each do |child|
-                            output_files(child).each do |file|
-                                return true if File.mtime(file) > t
-                            end
-                        end
-                        target.deps.each do |dep|
-                            if is_linked && dep.is_a?(Cpp::Library) &&
-                                dep[:libtype] != 'dynamic'
-                                output_files(dep).each do |file|
-                                    return true if File.mtime(file) > t
-                                end
-                            end
-                        end
+
+                module Executable
+                    def products
+                        return toolset.exe_fn(self)
                     end
-                    return false
                 end
-                
-                def clean(target)
-                    output_files(target).each { |file| FileUtils.rm_f(file) }
+
+                def initialize(sys)
+                    super
+                    constructor :syslib, Cpp::SystemLibrary
+                    constructor :lib, Cpp::Library
+                    constructor :exe, Cpp::Executable
+                end
+
+                def build(target)
                     if target.is_a?(Cpp::Object)
-                        filename = "#{target[:outdir]}/#{target.src.basename}.includes"
-                        FileUtils.rm_f(filename)
+                        compile(target)
+                    elsif target.is_a?(Cpp::Library)
+                        ar(target)
+                    elsif target.is_a?(Cpp::Executable)
+                        link(target)
+                    else
+                        raise "unknown Cpp target of class '#{target.class}"
                     end
                 end
                 
@@ -84,13 +49,6 @@ module Bake
                     return out.to_a if out.respond_to?(:to_a)
                     return [ out ]
                 end
-
-                def sh(*args)
-                    cmd = args.join(' ')
-                    puts cmd
-                    system(*args)
-                    raise "error: #{cmd}" if !$? || !$?.success?
-                end
             end
         end
     end

data/lib/bake/plugins/runner.rb

@@ -0,0 +1,40 @@
+require 'bake/target'
+require 'fileutils'
+
+module Bake
+    module Plugins
+        class Runner < Target
+            def post_initialize(exe)
+                @exe = nil
+                dep(exe)
+            end
+
+            def add_dep(target)
+                @exe = target if !@exe
+                deps << target
+            end
+
+            def path
+                return @exe.path if @exe.is_a?(FileTarget)
+                return @exe.run_command
+            end
+
+            alias :id :path
+
+            def build
+                toolset.sys.sh(path)
+                toolset.sys.touch(products)
+            end
+
+            def products
+                return File.join(get(:outdir), output_basename)
+            end
+
+        private
+            def output_basename
+                return path.basename + '.success'
+            end
+        end
+    end
+end
+

data/lib/bake/plugins/system.rb

@@ -1,18 +1,18 @@
-require 'bake/addon'
+require 'bake/toolset'
 
 module Bake
     module Plugins
-        class System
-            include Addon
-
-            def initialize
+        class System < Toolset
+            def initialize(sys)
+                super
                 command(:glob)
+                constructor(:run, Plugins::Runner)
             end
 
             def glob(context, *args)
                 has_options = args.last.respond_to?(:to_hash)
                 options = has_options ? args.pop.to_hash : {}
-                exclude = array_opt(options, :exclude)
+                exclude = options[:exclude].make_array
                 files = []
                 args.each do |pat|
                     matches = Dir[pat]
@@ -22,24 +22,8 @@ module Bake
                         end
                     end
                 end
-                if block_given?
-                    for i in 0...files.size
-                        yield(files[i])
-                    end
-                end
                 return files
             end
-
-        private
-            def array_opt(options, name)
-                opt = options[name]
-                return [] if !opt
-                if opt.respond_to?(:to_ary)
-                    opt = opt.to_ary
-                else
-                    opt = [ opt ]
-                end
-            end
         end
     end
 end

data/lib/bake/project.rb

@@ -2,11 +2,11 @@ require 'bake/target'
 
 module Bake
     class Project < Target
-        attr_accessor :loader
+        attr_reader :loader
 
-        def initialize(parent, loader)
-            super(parent, nil)
+        def post_initialize(loader)
             @loader = loader
+            @mappings = {}
         end
 
         def current_project
@@ -24,26 +24,67 @@ module Bake
             return child || loader.load_project(self, name)
         end
 
+        def map(mappings)
+            @mappings.merge!(mappings)
+        end
+
+        # Returns the target found at +path+ relative to this project.
+        # Raises a +RuntimeError+ if no such target is found.
+        #
+        # The +path+ argument is of the form:
+        #   <dir>:<name> | <name> | <dir>
         def resolve(path)
+            search_projects = ([ self ] + get(:search_projects))
             index = path.index(':')
-            raise "invalid path '#{path}'" if !index
-            dir = path.slice(0, index)
-            name = path.slice(index + 1, path.length - index - 1)
-            proj = self
-            dir.split('/').each do |el|
-                if el == '.'
-                    next
-                elsif el == '..'
-                    proj = proj.parent_project
-                    raise "invalid target path '#{path}'" if !proj
-                else
-                    proj = proj.child_project(el)
-                    raise "invalid target path '#{path}'" if !proj
+            if index
+                # search for a fully qualified target given by dir:name
+                dir = path.slice(0, index)
+                name = path.slice(index + 1, path.length - index - 1)
+            else
+                if !path.index('/') && path != '.' && path != '..'
+                    # search for target named by path in search_projects
+                    target = nil
+                    search_projects.each do |proj|
+                        target = proj.find_target(path)
+                        return target if target
+                    end
                 end
+                # search for a project at given path
+                dir = path
+                name = nil
             end
-            target = proj.children.find { |child| child.name == name }
-            raise "invalid target path '#{path}'" if !target
-            return target
+            
+            # iterate the search_projects looking for target given by dir:name
+            search_projects.each do |proj|
+                dir.split('/').each do |el|
+                    if el == '.'
+                        next
+                    elsif el == '..'
+                        proj = proj.parent_project
+                        break if !proj
+                    else
+                        begin
+                            proj = proj.child_project(el)
+                        rescue ProjectLoadError
+                            proj = nil
+                            break
+                        end
+                    end
+                end
+                # found a project at dir, find a child named name
+                if proj
+                    return proj if !name
+                    target = proj.find_target(name)
+                    return target if target
+                end
+            end
+            raise "invalid target path '#{path}'"
+        end
+
+    protected
+        def find_target(name)
+            return resolve(@mappings[name]) if @mappings.has_key?(name)
+            return children.find { |child| child.name == name }
         end
     end
 end

data/lib/bake/project_loader.rb

@@ -2,6 +2,8 @@ require 'bake/target'
 require 'bake/project'
 
 module Bake
+    class ProjectLoadError < RuntimeError; end
+
     class ProjectLoader
         attr_reader :invok_project
 
@@ -11,10 +13,17 @@ module Bake
             load_invok_project
         end
 
+        # Loads a child project of the project given by +parent+. It does this
+        # by searching for directory called +name+ in +parent+'s +:cwdir+.
+        # Raises a +ProjectLoadError+ if no such directory exists. If the
+        # directory contains a bakefile, it will be processed in this
+        # +ProjectLoader+'s context.
         def load_project(parent, name)
             dir = File.join(parent[:cwdir], name)
-            raise "no such directory '#{dir}'" if !File.directory?(dir)
-            proj = Project.new(parent, self)
+            if !File.directory?(dir)
+                raise ProjectLoadError, "no such directory '#{dir}'"
+            end
+            proj = Project.new(parent, @context.default_toolset, self)
             proj.name = name
             proj.opt(:projname => name)
             proj.opt(:cwdir => dir)
@@ -30,8 +39,8 @@ module Bake
             while true
                 bakefile = File.join(dir, 'root.bake')
                 if File.exists?(bakefile)
-                    project = Project.new(nil, self)
-                    project.req(:rootdir => dir)
+                    project = Project.new(nil, @context.default_toolset, self)
+                    project.opt(:rootdir => dir)
                     project.opt(:projname => 'root')
                     project.opt(:cwdir => dir)
                     project.opt(:outdir => '${cwdir}')

data/lib/bake/system_utils.rb

@@ -0,0 +1,42 @@
+require 'fileutils'
+
+module Bake
+    class SystemUtils
+        def initialize(options = {})
+            @options = options
+            if options[:dry_run]
+                @file_utils = FileUtils::DryRun
+            elsif options[:verbose]
+                @file_utils = FileUtils::Verbose
+            else
+                @file_utils = FileUtils
+            end
+        end
+
+        def dry_run?
+            return @options[:dry_run]
+        end
+        
+        def verbose?
+            return @options[:dry_run] || @options[:verbose]
+        end
+        
+        def sh(*args)
+            cmd = args.join(' ')
+            puts cmd if verbose?
+            if !dry_run?
+                system(*args)
+                raise "error: #{cmd}" if !$? || !$?.success?
+            end
+        end
+        
+        def fwrite(file, contents)
+            puts "writing '#{file}'" if verbose?
+            File.open(file, "w") { |f| f.puts(contents) } if !dry_run?
+        end
+        
+        def method_missing(name, *args)
+            @file_utils.send(name, *args)
+        end
+    end
+end