bake 0.1.0 → 0.1.1

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

@@ -0,0 +1,98 @@
+require 'bake/toolset'
+require 'fileutils'
+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
+                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
+                    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
+                    end
+                    return false
+                end
+                
+                def clean(target)
+                    output_files(target).each { |file| FileUtils.rm_f(file) }
+                    if target.is_a?(Cpp::Object)
+                        filename = "#{target[:outdir]}/#{target.src.basename}.includes"
+                        FileUtils.rm_f(filename)
+                    end
+                end
+                
+                def output_files(target)
+                    out = output(target)
+                    return [] if !out
+                    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
+end
+

data/lib/bake/plugins/macro.rb

@@ -0,0 +1,18 @@
+require 'bake/addon'
+
+module Bake
+    module Plugins
+        class Macro
+            include Addon
+
+            def initialize
+                command(:macro)
+            end
+
+            def macro(context, name, &block)
+                context.register(name, &block)
+            end
+        end
+    end
+end
+

data/lib/bake/plugins/system.rb

@@ -0,0 +1,46 @@
+require 'bake/addon'
+
+module Bake
+    module Plugins
+        class System
+            include Addon
+
+            def initialize
+                command(:glob)
+            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)
+                files = []
+                args.each do |pat|
+                    matches = Dir[pat]
+                    matches.each do |file|
+                        if !exclude.find { |exc| File.fnmatch(exc, file) }
+                            files.push(file) 
+                        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

@@ -0,0 +1,50 @@
+require 'bake/target'
+
+module Bake
+    class Project < Target
+        attr_accessor :loader
+
+        def initialize(parent, loader)
+            super(parent, nil)
+            @loader = loader
+        end
+
+        def current_project
+            return self
+        end
+
+        def parent_project
+            return parent ? parent.current_project : nil
+        end
+
+        def child_project(name)
+            child = children.find do |child|
+                child.name == name && child.is_a?(Project)
+            end
+            return child || loader.load_project(self, name)
+        end
+
+        def resolve(path)
+            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
+                end
+            end
+            target = proj.children.find { |child| child.name == name }
+            raise "invalid target path '#{path}'" if !target
+            return target
+        end
+    end
+end
+

data/lib/bake/project_loader.rb

@@ -1,4 +1,5 @@
 require 'bake/target'
+require 'bake/project'
 
 module Bake
     class ProjectLoader
@@ -10,18 +11,14 @@ module Bake
             load_invok_project
         end
 
-        def load_project(name, from_proj)
-            proj = from_proj.child(name, Project)
-            if !proj
-                dir = File.join(from_proj[:cwdir], name)
-                raise "no such directory #{dir}" if !File.exists?(dir)
-                proj = Project.new(from_proj)
-                proj.loader = self
-                proj.name = name
-                proj.opt(:projname => name)
-                proj.opt(:cwdir => dir)
-                process(proj)
-            end
+        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)
+            proj.name = name
+            proj.opt(:projname => name)
+            proj.opt(:cwdir => dir)
+            process(proj)
             return proj
         end
 
@@ -33,8 +30,7 @@ module Bake
             while true
                 bakefile = File.join(dir, 'root.bake')
                 if File.exists?(bakefile)
-                    project = Project.new(nil)
-                    project.loader = self
+                    project = Project.new(nil, self)
                     project.req(:rootdir => dir)
                     project.opt(:projname => 'root')
                     project.opt(:cwdir => dir)
@@ -56,7 +52,7 @@ module Bake
         def load_invok_project
             project = @root_project
             @invok_path.reverse_each do |name|
-                project = load_project(name, project)
+                project = load_project(project, name)
             end
             @invok_project = project
             return project

data/lib/bake/string_utils.rb

@@ -15,5 +15,9 @@ class String
     def extname
         return File.extname(self)
     end
+
+    def underscore
+        return gsub(/([a-z0-9])([A-Z])/) { |val| $1 + '_' + $2 }.downcase
+    end
 end
 

data/lib/bake/target.rb

@@ -1,115 +1,78 @@
 require 'bake/configuration'
+require 'bake/string_utils'
 
 module Bake
     class Target
         include Configuration
 
-        attr_reader :parent, :children, :deps
+        attr_reader :parent, :children, :deps, :toolset
         attr_accessor :name
 
-        def initialize(parent)
+        def initialize(parent, toolset)
             @parent = parent
+            @toolset = toolset
             @children = []
             @deps = []
             parent.children << self if parent
-            opt(:built? => false)
-        end
 
-        def child(name, klazz = nil)
-            if klazz
-                return children.find do |child|
-                    child.name == name && child.is_a?(klazz)
+            if toolset
+                mixin_name = self.class.name.split('::').last
+                toolset.class
+                if toolset.class.const_defined?(mixin_name)
+                    extend(toolset.class.const_get(mixin_name))
                 end
             end
-            return children.find { |child| child.name == name }
+            post_initialize if respond_to?(:post_initialize)
         end
 
-        def find(name)
-            target = children.find do |child|
-                !child.is_a?(Project) && child.name == name
-            end
-            target ||= parent.find(name) if parent
-            return target
-        end
-
-        def dep(*targets)
-            ret = []
-            targets.each do |target|
-                if !target.is_a?(Target)
-                    real_target = parent.find(target) if parent
-                    raise "uknown target '#{target}'" if !real_target
-                    target = real_target
+        def build
+            return if @built
+            deps.each { |dep| dep.build }
+            children.each { |child| child.build }
+            if toolset
+                Dir.chdir(get(:cwdir)) do
+                    toolset.build(self)
                 end
-                deps << target
-                ret << target
             end
-            return ret
+            @built = true
         end
 
-        def to_s(level = 0)
-            str = (' ' * level) + (@name || '<empty>') +
-                ' (' + self.class.name + ')'
-            if !deps.empty?
-                str += ' => '
-                deps.each do |target|
-                    str += target.name + ' (' + target.class.name + ') '
-                end
-            end
-            str += "\n"
-            if !children.empty?
-                children.each { |target| str += target.to_s(level + 1) }
-            end
-            return str
+        def clean
+            children.each { |child| child.clean }
+            toolset.clean(self) if toolset
         end
-    end
 
-    class Project < Target
-        SCHEME = nil
-
-        attr_accessor :loader
+        def dep(*targets)
+            targets = normalize_targets(*targets)
+            targets.each { |target| add_dep(target) }
+        end
 
-        def initialize(parent)
-            super(parent)
-            @mappings = {}
+        def add_dep(target)
+            deps << target
         end
 
-        def map(mappings)
-            mappings.each do |name, loc|
-                raise "target '#{name}' already mapped" if @mappings[name]
-                @mappings[name] = loc
-            end
+        def current_project
+            return parent.current_project
         end
 
-        def mapping(name)
-            target = nil
-            mapping = @mappings[name]
-            if mapping
-                if mapping.instance_of?(String)
-                    path = @mappings[name].split('/')
-                    proj = self
-                    path.each do |dir|
-                        proj = loader.load_project(dir, proj)
+    private
+        def normalize_targets(*targets)
+            normalized_targets = []
+            targets.flatten.each do |target|
+                if !target.is_a?(Target)
+                    if File.exists?(target)
+                        target = FileTarget.new(self, target)
+                    else
+                        target = current_project.resolve(target)
                     end
-                    target = proj.child(name)
-                    @mappings[name] = target
-                    raise "invalid mapping #{@mappings[name]}" if !target
-                elsif mapping.is_a?(Target)
-                    target = mapping
-                else
-                    raise "mapping has invalid class '#{mapping.class.name}'"
                 end
+                normalized_targets << target
             end
-            return target
-        end
-
-        def find(name)
-            target = mapping(name)
-            target ||= children.find do |child|
-                !child.is_a?(Project) && child.name == name
-            end
-            target ||= parent.find(name) if parent
-            return target
+            return normalized_targets
         end
     end
 end
 
+require 'bake/file_target'
+require 'bake/project'
+

data/lib/bake/toolset.rb

@@ -1,10 +1,17 @@
+require 'bake/plugin'
+
 module Bake
-    class Toolset
-        def sh(*args)
-            cmd = args.join(' ')
-            puts cmd
-            system(*args)
-            raise "error: #{cmd}" if !$? || !$?.success?
+    module Toolset
+        include Addon
+
+        def constructor(name, target_class)
+            toolset = self
+            command(name) do |*args|
+                block = args.last.is_a?(Proc) ? args.pop : nil
+                target = target_class.new(current, toolset, *args)
+                context_eval(target, &block) if block
+                return target
+            end
         end
     end
 end