bake 0.1.0 → 0.1.1

data/lib/bake/qt_scheme.rb

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

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

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