bake 0.1.2 → 0.2.0

data/lib/bake/system_utils.rb

@@ -1,42 +0,0 @@
-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

data/lib/bake/target.rb

@@ -1,155 +0,0 @@
-require 'bake/configuration'
-require 'bake/toolset'
-
-module Bake
-    class Target
-        include Configuration
-
-        attr_reader :parent, :children, :deps, :posts, :toolset
-        attr_accessor :name
-
-        def initialize(parent, *args)
-            @parent = parent
-            @children = []
-            @deps = []
-            @posts = []
-            @stale = nil
-            parent.children << self if parent
-
-            @toolset = args.first.is_a?(Toolset) ? args.shift : nil
-            @building = false
-            props = args.last.respond_to?(:to_hash) ? args.pop : {}
-            props.each_pair { |name, val| opt(name => val) }
-
-            post_initialize(*args) if respond_to?(:post_initialize)
-            mix_in_toolset
-        end
-        
-        def stale?
-            return @stale if !@stale.nil?
-            tmin = mtimes.min
-            @stale = deps.any? { |dep| dep.stale? || dep.mtimes.max > tmin }
-            return @stale
-        end
-
-        def products
-            return nil
-        end
-
-        def built?
-            return @built
-        end
-        
-        def build_r
-            return if @built
-            raise "circular dependency detected in '#{self}'" if @building
-            @building = true
-            deps.each { |dep| dep.build_r }
-            Dir.chdir(get(:cwdir)) do
-                if stale?
-                    if products
-                        outdir = get(:outdir)
-                        toolset.sys.mkdir_p(outdir) if !File.exists?(outdir)
-                    end
-                    build if respond_to?(:build)
-                end
-            end
-            @building = false
-            @built = true
-            posts.each { |post| post.build_r }
-        end
-
-        def clean_r
-            children.each { |child| child.clean_r }
-            clean
-        end
-
-        def clean
-            prods = products.make_array
-            toolset.sys.rm_f(prods) if !prods.empty?
-        end
-
-        def dep(*targets)
-            targets = normalize_targets(*targets)
-            targets.each { |target| add_dep(target) }
-        end
-
-        def add_dep(target)
-            deps << target
-        end
-
-        def post(*targets)
-            normalize_targets(*targets).each { |target| posts << target }
-        end
-
-        def current_project
-            return parent.current_project
-        end
-        
-        def mtimes
-            prods = products.make_array
-            return [ Time.now ] if prods.empty?
-            return products.make_array.collect do |prod|
-                File.exists?(prod) ? File.mtime(prod) : Time.at(0)
-            end
-        end
-
-        alias :id :name
-
-        def to_s
-            return "<#{class_name}: #{id}>"
-        end
-
-    protected
-        def class_name
-            return self.class.name.split('::').last
-        end
-
-    private
-        def normalize_targets(*targets)
-            normalized_targets = []
-            targets.flatten.each do |target|
-                if !target.is_a?(Target)
-                    begin
-                        # resolve normal targets
-                        target = current_project.resolve(target)
-                    rescue RuntimeError => e
-                        # when no normal target exists, see if a file exists
-                        if File.exists?(target)
-                            target = FileTarget.new(self, toolset, target)
-                        else
-                            raise e
-                        end
-                    end
-                end
-                normalized_targets << target
-            end
-            return normalized_targets
-        end
-
-        def mix_in_toolset
-            return if !toolset
-            mixin_name = self.class.name.split('::').last
-            # collect all the relevant mixins
-            modules = []
-            toolset_class = toolset.class
-            while toolset_class && !toolset_class.equal?(::Object)
-                if toolset_class.const_defined?(mixin_name)
-                    modules << toolset_class.const_get(mixin_name)
-                end
-                toolset_class = toolset_class.superclass
-            end
-            # add them in reverse order to preserve inheritance relations
-            modules.reverse_each do |mod|
-                extend(mod)
-                if mod.instance_methods.include?('post_initialize')
-                    post_initialize
-                end
-            end
-        end
-    end
-end
-
-require 'bake/file_target'
-require 'bake/project'
-

data/lib/bake/toolset.rb

@@ -1,25 +0,0 @@
-require 'bake/plugin'
-require 'fileutils'
-
-module Bake
-    class Toolset
-        include Addon
-        
-        attr_reader :sys
-        
-        def initialize(sys)
-            @sys = sys
-        end
-
-        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
-

data/lib/bake_version.rb

@@ -1,5 +0,0 @@
-module Bake
-    VERSION = [ 0, 1, 2 ]
-    VERSION_STRING = VERSION.join('.')
-end
-

data/test/test_bake.rb

@@ -1,2 +0,0 @@
-require 'test_configuration'
-

data/test/test_configuration.rb

@@ -1,58 +0,0 @@
-$: << File.dirname(__FILE__) + '/../lib'
-
-require 'test/unit'
-require 'bake/configuration'
-
-class ConfigTree
-    include Bake::Configuration
-
-    def initialize(parent = nil)
-        @parent = parent
-        parent.children << self if parent
-        @children = []
-    end
-
-protected
-    attr_reader :parent, :children
-end
-
-class TestConfigTree < Test::Unit::TestCase
-    def setup
-        @cfg = ConfigTree.new
-        @parent = ConfigTree.new
-        @child = ConfigTree.new(@parent)
-    end
-
-    def test_opt
-        assert_raise(RuntimeError) { @cfg.opt(:yes => true, :no => false) }
-        assert_raise(RuntimeError) { @cfg.opt(:yes => true, :no => false) }
-
-        @cfg.opt(:defines => 'DEBUG')
-        assert_equal(1, @cfg[:defines].size)
-        assert(@cfg[:defines].include?('DEBUG'))
-
-        @cfg.opt(:defines => 'WIN32')
-        assert_equal(2, @cfg[:defines].size)
-        assert(@cfg[:defines].include?('DEBUG'))
-        assert(@cfg[:defines].include?('WIN32'))
-
-        @cfg.opt(:libtype => 'static')
-        assert_equal('static', @cfg[:libtype])
-
-        @cfg.opt(:libtype => 'dynamic')
-        assert_equal('dynamic', @cfg[:libtype])
-
-        assert_raise(Bake::PropertyNotFoundException) { @cfg[:random] }
-
-        assert_equal(0, @child[:defines].size)
-
-        @parent.opt(:defines => 'DEBUG')
-        @child.opt(:defines => 'WIN32')
-        assert_equal(1, @parent[:defines].size)
-        assert(@child[:defines].include?('DEBUG'))
-        assert_equal(2, @child[:defines].size)
-        assert(@child[:defines].include?('DEBUG'))
-        assert(@child[:defines].include?('WIN32'))
-    end
-end
-