bake 0.1.2 → 0.2.0

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

@@ -1,118 +0,0 @@
-require 'fileutils'
-
-module Bake
-    module Plugins
-        module Cpp
-            class Msvc < ToolsetBase
-                def output(target)
-                    if target.is_a?(Object)
-                        return obj_fn(target)
-                    elsif target.is_a?(Library)
-                        return lib_fn(target)
-                    elsif target.is_a?(Executable)
-                        return exe_fn(target)
-                    end
-                    return nil
-                end
-                
-                def compile(obj)
-                    src = obj.src
-                    output = obj_fn(obj)
-                    flags = build_flags('/I', obj[:incdirs] + obj[:sysincdirs]) +
-                        build_flags('/D', obj[:defines])
-                    flags += obj[:cflags].join(' ')
-                    flags += ' /MD'
-                    flags += ' /EHsc' if obj[:exceptions?]
-                    flags += ' /GR' if obj[:rtti?]
-                    flags += obj[:optimizations?] ? ' /O2' : ' /Od'
-                    flags += ' /Z7' if obj[:debug_symbols?]
-                    sys.sh("cl /nologo #{flags} /c /Fo#{output} /Tp#{src}")
-                end
-                
-                def ar(lib)
-                    obj_str, flags = process_inputs(lib)
-                    
-                    output = lib_fn(lib)
-                    if lib[:libtype] == 'dynamic'
-                        flags += ' /debug' if lib[:debug_symbols?]
-                        sys.sh("link /nologo /dll #{flags} /out:#{output[1]} #{obj_str}")
-                        # need to touch the .exp file because it sometimes
-                        # doesn't get updated
-                        sys.touch(output[2])
-                    else
-                        sys.sh("lib /nologo /out:#{output} #{obj_str}")
-                    end
-                end
-                
-                def link(exe)
-                    obj_str, flags = process_inputs(exe)
-                    
-                    output = exe_fn(exe)
-                    flags += ' /debug' if exe[:debug_symbols?]
-                    sys.sh("link /nologo /subsystem:console #{flags} /out:#{output} #{obj_str}")
-                end
-                
-                def obj_fn(obj)
-                    src = obj.src
-                    basename = File.basename(src, File.extname(src)) + '.obj'
-                    return File.join(obj[:outdir], basename)
-                end
-                
-                def lib_fn(lib)
-                    if lib[:libtype] == 'dynamic'
-                        return [File.join(lib[:outdir], "#{lib.name}.lib"),
-                            File.join(lib[:outdir], "#{lib.name}.dll"),
-                            File.join(lib[:outdir], "#{lib.name}.exp")]
-                    end
-                    return File.join(lib[:outdir], "#{lib.name}.lib")
-                end
-                
-                def exe_fn(exe)
-                    return File.join(exe[:outdir], exe.name + '.exe')
-                end
-                
-            private
-                def build_flags(flag, args)
-                    return args.inject('') { |str, arg| str + "#{flag}#{arg} " }
-                end
-                
-                def process_inputs(target)
-                    output = output(target)
-                    obj_str = ''
-                    libdirs = []
-                    static_lib = target.is_a?(Library) && target[:libtype] == 'static'
-                    target.deps.each do |input|
-                        if input.is_a?(Object)
-                            fn = obj_fn(input)
-                            obj_str += fn + ' '
-                        elsif input.is_a?(SystemLibrary)
-                            if !static_lib
-                                obj_str += input.file + '.lib '
-                            end
-                        elsif input.is_a?(Library)
-                            if !static_lib
-                                if input[:libtype] == 'dynamic'
-                                    fn = lib_fn(input)[0]
-                                else
-                                    fn = lib_fn(input)
-                                end
-                                libdir = File.dirname(fn)
-                                libdirs << libdir if !libdirs.include?(libdir)
-                                obj_str += File.basename(fn) + ' '
-                            end
-                        end
-                    end
-                    
-                    if !static_lib
-                        target[:libs].each { |lib| obj_str += lib + '.lib ' }
-                    end
-                    libdirs.concat(target[:libdirs])
-                    flags = build_flags('/LIBPATH:', libdirs)
-                    
-                    return [ obj_str, flags ]
-                end
-            end
-        end
-    end
-end
-

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

@@ -1,53 +0,0 @@
-require 'bake/toolset'
-require 'fileutils'
-
-module Bake
-    module Plugins
-        module Cpp
-            module Qt
-                class Moc < Toolset
-                    def initialize(sys)
-                        super
-                        command(:moc)
-                    end
-
-                    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 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
-
-                class MocFile < Source
-                    def src
-                        return @source.path
-                    end
-
-                    def path
-                        src = @source.path
-                        ext = File.extname(src)
-                        basename = File.basename(src, ext) + '.moc' + ext
-                        return File.join(get(:outdir), basename)
-                    end
-
-                    alias :products :path
-
-                    def build
-                        toolset.build(self)
-                    end
-                end
-            end
-        end
-    end
-end
-

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

@@ -1,56 +0,0 @@
-require 'bake/toolset'
-require 'fileutils'
-require 'set'
-
-module Bake
-    module Plugins
-        module Cpp
-            class ToolsetBase < Toolset
-                module Object
-                    def products
-                        return toolset.obj_fn(self)
-                    end
-                end
-
-                module Library
-                    def products
-                        return toolset.lib_fn(self)
-                    end
-                end
-
-                module Executable
-                    def products
-                        return toolset.exe_fn(self)
-                    end
-                end
-
-                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)
-                        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
-                
-                def output_files(target)
-                    out = output(target)
-                    return [] if !out
-                    return out.to_a if out.respond_to?(:to_a)
-                    return [ out ]
-                end
-            end
-        end
-    end
-end
-

data/lib/bake/plugins/macro.rb

@@ -1,18 +0,0 @@
-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/runner.rb

@@ -1,40 +0,0 @@
-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,30 +0,0 @@
-require 'bake/toolset'
-
-module Bake
-    module Plugins
-        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 = options[:exclude].make_array
-                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
-                return files
-            end
-        end
-    end
-end
-

data/lib/bake/project.rb

@@ -1,91 +0,0 @@
-require 'bake/target'
-
-module Bake
-    class Project < Target
-        attr_reader :loader
-
-        def post_initialize(loader)
-            @loader = loader
-            @mappings = {}
-        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 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(':')
-            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
-            
-            # 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

@@ -1,116 +0,0 @@
-require 'bake/target'
-require 'bake/project'
-
-module Bake
-    class ProjectLoadError < RuntimeError; end
-
-    class ProjectLoader
-        attr_reader :invok_project
-
-        def initialize(context, invok_dir, props)
-            @context = context
-            load_root_project(invok_dir, props)
-            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)
-            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)
-            process(proj)
-            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, @context.default_toolset, self)
-                    project.opt(: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(project, name)
-            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
-