bake 0.1.0

data/lib/bake/project_loader.rb

@@ -0,0 +1,111 @@
+require 'bake/target'
+
+module Bake
+    class ProjectLoader
+        attr_reader :invok_project
+
+        def initialize(context, invok_dir, props)
+            @context = context
+            load_root_project(invok_dir, props)
+            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
+            return proj
+        end
+
+    private
+        def load_root_project(invok_dir, props)
+            project = nil
+            dir = invok_dir
+            @invok_path = []
+            while true
+                bakefile = File.join(dir, 'root.bake')
+                if File.exists?(bakefile)
+                    project = Project.new(nil)
+                    project.loader = self
+                    project.req(:rootdir => dir)
+                    project.opt(:projname => 'root')
+                    project.opt(:cwdir => dir)
+                    project.opt(:outdir => '${cwdir}')
+                    props.each_pair { |key, val| project.opt(key => val) }
+                    break
+                end
+
+                parent_dir = File.dirname(dir)
+                raise 'root.bake not found' if parent_dir == dir
+                @invok_path << File.basename(dir)
+                dir = parent_dir
+            end
+
+            @root_project = project
+            process(@root_project)
+        end
+
+        def load_invok_project
+            project = @root_project
+            @invok_path.reverse_each do |name|
+                project = load_project(name, project)
+            end
+            @invok_project = project
+            return project
+        end
+
+        def process(proj)
+            if proj.parent
+                dir = proj[:cwdir]
+                bakefile = File.join(dir, 'sub.bake')
+                if File.exists?(bakefile)
+                    Dir.chdir(dir) { eval_bakefile(proj, bakefile) }
+                end
+            else
+                raise 'internal error' if !@root_project.equal?(proj)
+                Dir.chdir(@root_project[:cwdir]) do
+                    if config_bakefile
+                        eval_bakefile(@root_project, config_bakefile)
+                    end
+                    eval_bakefile(@root_project, root_bakefile)
+                end
+            end
+        end
+
+        def eval_bakefile(project, bakefile)
+            @context.context_eval(project, File.read(bakefile), bakefile)
+        end
+
+        def root_bakefile
+            return @root_bakefile if @root_bakefile
+            @root_bakefile = File.join(@root_project[:cwdir], 'root.bake')
+            return @root_bakefile
+        end
+
+        def config_bakefile
+            return @config_bakefile if @config_bakefile
+            bakefile = File.join(@root_project[:cwdir], 'config.bake')
+            if !File.exists?(bakefile)
+                home = ENV['HOME']
+                if home
+                    bakefile = File.join(home, 'config.bake')
+                    if !File.exists?(bakefile)
+                        bakefile = nil
+                    end
+                else
+                    bakefile = nil
+                end
+            end
+            return @config_bakefile = bakefile
+        end
+    end
+end
+

data/lib/bake/qt_scheme.rb

@@ -0,0 +1,62 @@
+require 'bake/toolset'
+require 'bake/target'
+require 'bake/cpp_scheme.rb'
+require 'fileutils'
+
+module Qt
+    class Moc < Bake::Toolset
+        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}")
+        end
+
+        def clean(target)
+            FileUtils.rm_f(target.output)
+        end
+
+        def stale?(target)
+            return true if !File.exists?(target.output)
+            return File.mtime(target.src) > File.mtime(target.output)
+        end
+
+        def sh(*args)
+            cmd = args.join(' ')
+            puts cmd
+            system(*args)
+            raise "error: #{cmd}" if !$? || !$?.success?
+        end
+    end
+
+    class MocFile < Bake::Target
+        attr_reader :output
+        attr_accessor :src
+
+        def initialize(parent, src)
+            super(parent)
+            ext = File.extname(src)
+            @output = File.basename(src, ext) + '.moc' + ext
+            @src = src
+        end
+    end
+end
+
+module Cpp
+    class Library
+        def moc(*args)
+            return args.flatten.collect do |file|
+                Qt::MocFile.new(Cpp::Object.new(self), file)
+            end
+        end
+    end
+
+    class Executable
+        def moc(*args)
+            return args.flatten.collect do |file|
+                Qt::MocFile.new(Cpp::Object.new(self), file)
+            end
+        end
+    end
+end
+

data/lib/bake/scheme.rb

@@ -0,0 +1,104 @@
+require 'bake/target'
+require 'bake/toolset'
+
+module Bake
+    class Scheme
+        attr_reader :name, :targets, :toolsets, :toolset
+
+        def initialize(mod)
+            @name = underscore(mod.name)
+            @module = mod
+            @targets = []
+            @toolsets = []
+            populate_targets_and_toolsets
+            raise "no toolsets in scheme '#{@name}'" if @toolsets.size == 0
+            raise "no targets in scheme '#{@name}'" if @targets.size == 0
+            @accessors = {}
+            populate_accessors
+        end
+
+        def toolset=(toolset)
+            if !toolset.is_a?(Toolset)
+                ts = toolset_class(toolset.to_s)
+                raise "could not find toolset '#{toolset}'" if !ts
+                @toolset = ts.new
+                return
+            end
+            if !@toolsets.include?(toolset.class)
+                raise "toolset #{toolset.class.name} is not in scheme #{name}"
+            end
+            @toolset = toolset
+        end
+
+        def has_constructor?(accessor)
+            return accessors.has_key?(accessor)
+        end
+
+        def construct(type, *args)
+            if type.instance_of?(Class)
+                target_class = type
+                raise "#{type} not in #{name}" if !targets.include?(type)
+            else
+                target_class = accessors[type]
+                raise "no such constructor #{type}" if !target_class
+            end
+            target = target_class.new(*args)
+            return target
+        end
+
+    private
+        attr_reader :accessors
+
+        def underscore(str)
+            str = str.gsub(/[A-Z][a-z0-9]*/) { |val| val.downcase + '_' }.chop
+            return str.gsub('_::', '/')
+        end
+
+        def capitalize(str)
+            str = str.gsub(/[a-z0-9]+/) { |val| val.capitalize }
+            return str.gsub('_', '')
+        end
+
+        def toolset_class(name)
+            name = @module.name + '::' + capitalize(name)
+            return @toolsets.find { |t| t.name == name }
+        end
+
+        def populate_targets_and_toolsets
+            @module.constants.each do |const|
+                klazz = @module.const_get(const.to_sym)
+                if klazz.instance_of?(Class)
+                    sup = klazz.superclass
+                    while sup
+                        if sup.equal?(Toolset)
+                            @toolsets << klazz
+                            break
+                        elsif sup.equal?(Target)
+                            @targets << klazz
+                            break
+                        end
+                        sup = sup.superclass
+                    end
+                end
+            end
+        end
+
+        def populate_accessors
+            @targets.each do |target|
+                if target.const_defined?(:ACCESSORS)
+                    accessors = target.const_get(:ACCESSORS)
+                    if accessors.respond_to?(:to_ary)
+                        accessors = accessors.to_ary
+                    else
+                        accessors = [ accessors ]
+                    end
+                    accessors.each { |accessor| @accessors[accessor] = target }
+                end
+                if !target.const_defined?(:SCHEME)
+                    target.const_set(:SCHEME, self)
+                end
+            end
+        end
+    end
+end
+

data/lib/bake/scheme_loader.rb

@@ -0,0 +1,28 @@
+require 'bake/scheme'
+
+module Bake
+    class SchemeLoader
+        attr_reader :schemes
+
+        def initialize
+            @schemes = {}
+        end
+
+        def scheme(name)
+            scheme = @schemes[name]
+            return scheme if scheme
+            return load_scheme(name)
+        end
+
+        def load_scheme(name)
+            file = File.join(File.dirname(__FILE__), "#{name}_scheme.rb")
+            raise "unknown scheme '#{name}'" if !File.exists?(file)
+            require "bake/#{name}_scheme"
+            mod = Bake.const_get(name.capitalize.to_sym)
+            scheme = Scheme.new(mod)
+            @schemes[scheme.name] = scheme
+            return scheme
+        end
+    end
+end
+

data/lib/bake/string_utils.rb

@@ -0,0 +1,19 @@
+class String
+    def basename(options = {})
+        if options[:ext]
+            return File.basename(self, extname) + options[:ext]
+        elsif options[:noext]
+            return File.basename(self, extname)
+        end
+        return File.basename(self)
+    end
+
+    def dirname
+        return File.dirname(self)
+    end
+
+    def extname
+        return File.extname(self)
+    end
+end
+

data/lib/bake/target.rb

@@ -0,0 +1,115 @@
+require 'bake/configuration'
+
+module Bake
+    class Target
+        include Configuration
+
+        attr_reader :parent, :children, :deps
+        attr_accessor :name
+
+        def initialize(parent)
+            @parent = parent
+            @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)
+                end
+            end
+            return children.find { |child| child.name == name }
+        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
+                end
+                deps << target
+                ret << target
+            end
+            return ret
+        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
+        end
+    end
+
+    class Project < Target
+        SCHEME = nil
+
+        attr_accessor :loader
+
+        def initialize(parent)
+            super(parent)
+            @mappings = {}
+        end
+
+        def map(mappings)
+            mappings.each do |name, loc|
+                raise "target '#{name}' already mapped" if @mappings[name]
+                @mappings[name] = loc
+            end
+        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)
+                    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
+            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
+        end
+    end
+end
+

data/lib/bake/toolset.rb

@@ -0,0 +1,11 @@
+module Bake
+    class Toolset
+        def sh(*args)
+            cmd = args.join(' ')
+            puts cmd
+            system(*args)
+            raise "error: #{cmd}" if !$? || !$?.success?
+        end
+    end
+end
+