bake 0.1.2 → 0.2.0

data/lib/bake/extensions/object.rb

@@ -1,22 +0,0 @@
-class Object
-    # If +self+ is nil, returns a zero-length array, otherwise, if +self+
-    # responds to the +to_ary+ method, returns +to_ary+. Otherwise, returns
-    # an array of length one containing +self+.
-    def make_array
-        if nil?
-            return []
-        elsif respond_to?(:to_ary)
-            return to_ary
-        end
-        return [ self ]
-    end
-
-    # Returns the singleton class for this object's class.
-    def metaclass
-        return class << self; self; end
-    end
-end
-
-main = self
-Object.metaclass.send(:define_method, :main_object) { main }
-Object.metaclass.send(:public, :main_object)

data/lib/bake/extensions/string.rb

@@ -1,22 +0,0 @@
-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
-
-    def underscore
-        return gsub(/([a-z0-9])([A-Z])/) { |val| $1 + '_' + $2 }.downcase
-    end
-end

data/lib/bake/file_target.rb

@@ -1,19 +0,0 @@
-require 'bake/target'
-
-module Bake
-    class FileTarget < Target
-        attr_reader :path
-
-        def post_initialize(path)
-            @path = path
-            @built = true
-        end
-
-        def mtimes
-            raise "file no longer exists '#{path}'" if !File.exists?(path)
-            return [ File.mtime(path) ]
-        end
-
-        alias :id :path
-    end
-end

data/lib/bake/plugin.rb

@@ -1,49 +0,0 @@
-module Bake
-    module PluginManager
-        def load_plugin(full_name)
-            plugin = Object.main_object.class
-            full_name.to_s.split('::').each do |name|
-                plugin = load_child_plugin(plugin, name)
-            end
-            return plugin
-        end
-
-        def load_child_plugin(parent, name)
-            name = name.to_s
-            full_name = parent.equal?(Object.main_object.class) ?
-                name : parent.name + '::' + name
-            plugin_file = full_name.underscore.gsub('::', '/')
-
-            plugin = nil
-            if parent.const_defined?(name)
-                plugin = parent.const_get(name)
-                return plugin if plugin.equal?(Bake)
-            end
-
-            search_dirs.each do |rootdir|
-                if File.exists?(File.join(rootdir, plugin_file + '.rb'))
-                    require plugin_file
-                    if !plugin && parent.const_defined?(name)
-                        plugin = parent.const_get(name)
-                    end
-                end
-
-                if File.directory?(File.join(rootdir, plugin_file))
-                    if !plugin
-                        plugin = Module.new
-                        parent.const_set(name, plugin)
-                    end
-                    plugin_manager = self
-                    plugin.metaclass.send(
-                        :define_method, :const_missing) do |name|
-                        return plugin_manager.load_child_plugin(self, name)
-                    end
-                end
-            end
-
-            raise "could not find plugin '#{name}'" if !plugin
-            return plugin
-        end
-    end
-end
-

data/lib/bake/plugins/cpp.rb

@@ -1,188 +0,0 @@
-require 'bake/target'
-
-module Bake
-    module Plugins
-        module Cpp
-            class SystemLibrary < Target
-                attr_reader :file
-
-                def post_initialize(name, file)
-                    @built = true
-                    @name = name
-                    @file = file
-                end
-
-                def products
-                    return nil
-                end
-
-                def mtimes
-                    return [ Time.at(0) ]
-                end
-            end
-            
-            # +MainTarget+ is a mix-in for the +Library+ and +Executable+
-            # classes containing code common to both types of targets.
-            module MainTarget
-                # A special override of +stale?+ that ignores changes to
-                # dlls when determining if this target is stale. The only
-                # case in which a lib or exe should have to update when a
-                # dll dependency is updated is when the interface changes.
-                # Since exes and libs depend on the headers implicitly,
-                # they will be updated if the interface changes
-                # automatically.
-                def stale?
-                    return @stale if !@stale.nil?
-                    tmin = mtimes.min
-                    @stale = deps.any? do |dep|
-                        is_dll = dep.is_a?(Library) &&
-                            dep[:libtype] == 'dynamic'
-                        (dep.stale? || dep.mtimes.max > tmin) && !is_dll
-                    end
-                    return @stale
-                end
-                
-                def add_dep(target)
-                    if target.is_a?(FileTarget)
-                        target = Source.new(self, toolset, target)
-                    end
-                    return super if !target.is_a?(Source)
-                    deps << Cpp::Object.new(self, toolset, target)
-                end
-
-                def build
-                    toolset.build(self)
-                end
-            end
-
-            class Library < Target
-                include MainTarget
-                
-                def post_initialize(name)
-                    @name = name
-                    default(:libtype => 'static')
-                    default(:debug_symbols? => false)
-                end
-            end
-
-            class Executable < Target
-                include MainTarget
-                
-                def post_initialize(name)
-                    @name = name
-                    default(:debug_symbols? => false)
-                end
-
-                # Enables +Executable+ to be run via a +Runner+ target.
-                def run_command
-                    return toolset.exe_fn(self)
-                end
-            end
-
-            class Source < Target
-                def post_initialize(source)
-                    @source = source
-                    @includes = IncludeList.new(self, toolset, source)
-                    dep(source, @includes)
-                end
-
-                def path
-                    return @source.path
-                end
-
-                alias :id :path
-
-                def mtimes
-                    return @includes.mtimes
-                end
-            end
-
-            class IncludeList < Target
-                attr_reader :includes
-
-                def post_initialize(source)
-                    @src = source.path
-                    if File.exists?(products)
-                        @includes = load_includes
-                        @calculated = false
-                    else
-                        @includes = calc_includes(@src)
-                        @calculated = true
-                    end
-                    dep(source, *@includes)
-                end
-                
-                def id
-                    return @src
-                end
-
-                def build
-                    @includes = calc_includes(@src) if !@calculated
-                    toolset.sys.fwrite(products, includes.to_a.join("\n"))
-                end
-
-                def products
-                    return "#{get(:outdir)}/#{@src.basename}.includes"
-                end
-
-            private
-                def load_includes
-                    includes = Set.new
-                    file = File.open(products)
-                    while line = file.gets
-                        line.chomp!
-                        includes << line if !line.empty?
-                    end
-                    file.close
-                    return includes
-                end
-
-                def calc_includes(src, include_fns = Set.new)
-                    new_include_fns = Set.new
-                    File.open(src) do |file|
-                        incdirs = get(:incdirs)
-                        while line = file.gets
-                            if line =~ /\s*#\s*include\s+("|<)([^"]+)("|>)/
-                                inc = $2
-                                incdirs.each do |include_dir|
-                                    fn = File.join(include_dir, inc)
-                                    break if include_fns.include?(fn)
-                                    if File.exists?(fn)
-                                        new_include_fns << fn
-                                        include_fns << fn
-                                        break
-                                    end
-                                end
-                            end
-                        end
-                    end
-                    
-                    new_include_fns.each do |inc|
-                        calc_includes(inc, include_fns)
-                    end
-                    return include_fns
-                end
-            end
-
-            class Object < Target
-                attr_reader :src
-                
-                alias :id :src
-
-                def post_initialize(source)
-                    @src = source.path
-                    dep(source)
-                    default(:exceptions? => true)
-                    default(:rtti? => true)
-                    default(:optimizations? => false)
-                    default(:multithreaded? => true)
-                end
-                
-                def build
-                    toolset.build(self)
-                end
-            end
-        end
-    end
-end
-

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

@@ -1,26 +0,0 @@
-module Bake
-    module Plugins
-        module Cpp
-            class Darwin < GccToolsetBase
-                def ar(lib)
-                    obj_str, lib_str, flags = process_inputs(lib)
-                    
-                    output = lib_fn(lib)
-                    if lib[:libtype] == 'dynamic'
-                        sys.sh("g++ #{flags} -dynamiclib -o #{output} #{obj_str} #{lib_str}")
-                    else
-                        sys.sh("ar rcs #{output} #{obj_str}")
-                    end
-                end
-                
-                def lib_fn(lib)
-                    if lib[:libtype] == 'dynamic'
-                        return File.join(lib[:outdir], "lib#{lib.name}.dylib")
-                    end
-                    return File.join(lib[:outdir], "lib#{lib.name}.a")
-                end
-            end
-        end
-    end
-end
-

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

@@ -1,14 +0,0 @@
-module Bake
-    module Plugins
-        module Cpp
-            class Gcc < GccToolsetBase
-                module Library
-                    def post_initialize
-                        opt(:cflags => '-fPIC') if get(:libtype) == 'dynamic'
-                    end
-                end
-            end
-        end
-    end
-end
-

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

@@ -1,101 +0,0 @@
-require 'fileutils'
-
-module Bake
-    module Plugins
-        module Cpp
-            class GccToolsetBase < ToolsetBase
-                def output(target)
-                    if target.is_a?(Cpp::Object)
-                        return obj_fn(target)
-                    elsif target.is_a?(Cpp::Library)
-                        return lib_fn(target)
-                    elsif target.is_a?(Cpp::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 += ' -fno-rtti' if !obj[:rtti?]
-                    flags += ' -O3' if obj[:optimizations?]
-                    flags += ' -g' if obj[:debug_symbols?]
-                    sys.sh("g++ -c -o #{output} #{flags} #{src}")
-                end
-                
-                def ar(lib)
-                    obj_str, lib_str, flags = process_inputs(lib)
-                    
-                    output = lib_fn(lib)
-                    if lib[:libtype] == 'dynamic'
-                        sys.sh("g++ #{flags} -shared -Wl,-soname,#{output} -o #{output} #{obj_str} #{lib_str}")
-                        if lib.has_prop?(:gcc_lib_path)
-                            fn = File.join(lib[:gcc_lib_path], output.basename)
-                            File.symlink(output, fn) if !File.exists?(fn)
-                        end
-                    else
-                        sys.sh("ar rcs #{output} #{obj_str}")
-                    end
-                end
-                
-                def link(exe)
-                    obj_str, lib_str, flags = process_inputs(exe)
-                    
-                    output = exe_fn(exe)
-                    sys.sh("g++ #{flags} -o #{output} #{obj_str} #{lib_str}")
-                end
-                
-                def obj_fn(obj)
-                    src = obj.src
-                    basename = File.basename(src, File.extname(src)) + '.o'
-                    return File.join(obj[:outdir], basename)
-                end
-                
-                def lib_fn(lib)
-                    if lib[:libtype] == 'dynamic'
-                        return File.join(lib[:outdir], "lib#{lib.name}.so")
-                    end
-                    return File.join(lib[:outdir], "lib#{lib.name}.a")
-                end
-                
-                def exe_fn(exe)
-                    return File.join(exe[:outdir], exe.name)
-                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 = ''
-                    lib_str = ''
-                    libdirs = []
-                    target.deps.each do |input|
-                        if input.is_a?(Cpp::Object)
-                            fn = obj_fn(input)
-                            obj_str += fn + ' '
-                        elsif input.is_a?(Cpp::SystemLibrary)
-                            lib_str += '-l' + input.file + ' '
-                        elsif input.is_a?(Cpp::Library)
-                            fn = lib_fn(input)
-                            lib_str += '-l' + input.name + ' '
-                            libdir = File.dirname(fn)
-                            libdirs << libdir if !libdirs.include?(libdir)
-                        end
-                    end
-                    
-                    libdirs.concat(target[:libdirs])
-                    flags = build_flags('-L', libdirs)
-                    return [ obj_str, lib_str, flags ]
-                end
-            end
-        end
-    end
-end
-