filament 0.1.0

data/lib/filament/resolver.rb

@@ -0,0 +1,91 @@
+module Filament
+  class PackageResolver
+    def initialize(parent_resolver=nil)
+      @parent = parent_resolver
+      @root_packages = []
+    end
+    
+    def <<(root_package)
+      @root_packages << root_package unless root_package.nil?
+    end
+    
+    def resolve(uri)
+      uri = uri.gsub(/^\/\//, '')
+      
+      @root_packages.each do |pkg|
+        subpkg = pkg.subpackage(uri)
+        return subpkg unless subpkg.nil?
+      end
+      
+      if @parent.nil?
+        return nil
+      else
+        return @parent.resolve(uri)
+      end
+    end
+    
+    def root_packages
+      if @parent.nil?
+        return @root_packages
+      else
+        return @root_packages + @parent.root_packages
+      end
+    end
+    
+    def root_package_names
+      root_packages.collect { |p| p.full_name }
+    end
+  end
+  
+  class TargetResolver
+    # format: //package_path:target_name	
+    TARGET_REGEX =  /^:([^:]+)$/
+    PACKAGE_REGEX = /^\/\/([^:]+)$/
+    FULL_REGEX =    /^\/\/([^:]+):([^:]+)$/
+    
+    def initialize(package)
+      @package = package
+      @package_resolver = @package.package_resolver
+    end
+
+    def valid_uri?(path)
+      return FULL_REGEX === path || TARGET_REGEX === path || PACKAGE_REGEX === path
+    end
+    
+    def resolve(uri)
+      package_path = nil
+      target_name = nil
+      
+      if FULL_REGEX === uri
+        package_path = $1
+        target_name = $2
+      end
+      
+      if TARGET_REGEX === uri
+        package_path = nil
+        target_name = $1
+      end
+
+      if PACKAGE_REGEX === uri
+        package_path = $1
+        target_name = nil
+      end
+
+      log "split_path(#{uri}) => package_path: #{package_path}, target_name: #{target_name}"
+
+      if package_path.nil?
+        package = @package
+        log "using default package '#{@package.uri}' for target '#{target_name}'"
+      else
+        package = @package_resolver.resolve(package_path)
+        raise "package '#{package_path}' not found in: #{@package_resolver.root_package_names.join(', ')}" if package.nil?
+      end
+
+      if target_name.nil?
+        return package[package.name]
+      else
+        return package[target_name]
+      end
+    end
+  end
+end

data/lib/filament/target.rb

@@ -0,0 +1,117 @@
+require 'filament/util/lazy_list'
+
+# TODO quick fixes..
+# switch to package.rb
+
+module Filament
+  class TargetList < LazyList
+    def initialize(*args)
+      @resolver = $context[:target_resolver]
+      super(*args)
+    end
+  end
+  
+  class Target
+    attr_reader :name, :package, :weak_deps, :deps, :deployables
+    
+    def initialize(args, &block)
+      if args.is_a? Hash
+        h = args
+        @name = h[:name]
+      else
+        @name = args
+        h = {}
+      end
+
+      weak_deps = h[:weak_deps] || []
+      deps = h[:deps] || []
+
+      @weak_deps = TargetList.new(*weak_deps)
+      @deps = TargetList.new(*deps)
+
+      @package = h[:package] || $context[:this_package]
+      @invoked = false
+      @block = block
+      @outputs = {}
+      @deployables = []
+      
+      raise 'targets must have a name' if @name.nil?
+      raise 'targets must have a package' if @package.nil?
+      
+      @package << self       
+    end
+    
+    def uri
+      return "#{@package.uri}:#{@name}"
+    end
+    
+    # for easy sorting
+    def <=>(other)
+      return (uri <=> other)
+    end
+    
+    # walks tree of dependencies, returns a complete list
+    def flattened_deps
+      all = @deps.to_a.clone
+      
+      fd = []
+      until all.empty?
+        d = all.pop
+        unless fd.include?(d)
+          fd << d
+          all += d.deps
+        end
+      end
+      return fd
+    end
+    
+    # adds some :output to the given :tag
+    # if :deployable is true, also adds :output to deployables
+    def output(h)
+      tag = h[:tag]
+      output = h[:output]
+      if tag.respond_to?(:to_ary)
+        tag.to_ary.each do |t|
+          output(:tag => t, :output => output)
+        end
+      else 
+        @outputs[tag] = output 
+      end
+      
+      @deployables << output if h[:deployable]
+    end
+    
+    # returns the value in the output hash for the given tag
+    def get_output(tag)
+      invoke
+      return @outputs[tag]
+    end
+    alias :[] :get_output
+
+    # builds this specific target (and all dependencies)
+    def build
+      @package.build_context.execute do
+        invoke
+      end
+    end
+    
+    # returns true if the target has completed
+    def done?
+      return @invoked
+    end
+    
+    def invoke
+      return if done?
+      @invoked = true
+      
+      puts ">>> BUILDING #{uri} (#{package.pathname}, #{self})"
+
+      @package.execute do
+        @weak_deps.each {|t| t.invoke}
+        @deps.each {|t| t.invoke}
+        instance_eval(&@block)
+      end
+    end
+  end
+end
+

data/lib/filament/util/filelist2.rb

@@ -0,0 +1,39 @@
+require 'filament/target'
+
+module Filament
+  class FileList2 < FileList
+    def initialize(*args)
+      super(*args)
+      @target_resolver = $context[:target_resolver]
+    end
+    
+    def resolve_filament_uris(*entries)
+      files = []
+      entries.each do |entry|
+        if entry.respond_to? :to_ary
+          resolve_uris(*entry.to_ary)
+        else
+          if @target_resolver.valid_uri?(entry)
+            target = @target_resolver.resolve(entry)
+            raise "target does not exist: #{entry}" if target.nil?
+            files << target[:default]
+          else
+            files << entry
+          end
+        end
+      end
+      
+#      puts "resolve_uris(#{entries.join(', ')}) => #{files.join(':')}"
+      return files
+    end
+
+    def resolve
+      super
+      @items.uniq!
+    end
+    
+    def include(*entries)
+      super(*resolve_filament_uris(*entries))
+    end
+  end
+end

data/lib/filament/util/fileutils.rb

@@ -0,0 +1,51 @@
+require 'fileutils'
+require 'pathname'
+
+module Filament
+  def cp_r_if(src, dest, &block)
+    src_p = Pathname.new(src)
+    dest_p = Pathname.new(dest)
+    
+    if yield src_p.to_s
+      dest_p = dest_p + src_p.basename if dest_p.exist? and dest_p.directory?
+      
+      if src_p.directory?
+        if dest_p.exist?
+          raise "will not replace file with directory: #{dest_p}" unless dest_p.directory?
+        else
+          FileUtils.mkdir(dest_p)
+        end
+
+  	    src_p.children.each do |src_child_p|
+          relative = src_child_p.relative_path_from(src_p)
+          dest_child_p = dest_p + relative
+          cp_r_if(src_child_p, dest_child_p, &block)
+        end
+      else
+        log "copying #{src_p} to #{dest_p}"
+        FileUtils.cp_r(src_p, dest_p)
+      end
+    else
+      log "skipping #{src_p}"
+    end
+  end
+  
+  # returns first parent of package_dir to contain a root_file
+  def self.find_dir(package_dir, *files)
+    p = Pathname.new(package_dir)
+  
+    until p.root? do
+      if p.directory?
+        files.each do |file| 
+          r = p + file
+          log "checking for #{r}"
+          return p.realpath if r.file?
+        end
+      end
+    
+      p = p.parent
+    end
+  
+    raise "Root directory not found for '#{package_dir}'"
+  end
+end

data/lib/filament/util/lazy_list.rb

@@ -0,0 +1,74 @@
+class LazyList
+  attr_accessor :resolver
+  
+  def initialize(*entries)
+    raise "resolver must be set by subclass." if @resolver.nil?
+    
+    @unresolved = []
+    @resolved = []
+    
+    entries.each do |entry|
+      include(entry)
+    end
+  end
+  
+  def include(entry_name)
+    if entry_name.respond_to?(:to_ary)
+      entry_name.to_ary.each do |t|
+        include(t)
+      end
+    else
+      if entry_resolved?(entry_name)
+        @resolved << entry_name
+      else
+        @unresolved << entry_name
+      end
+    end
+    return self
+  end
+  alias :<< :include
+
+  def length
+    return @unresolved.size + @resolved.size
+  end
+  alias :size :length 
+  
+  def empty?
+	  return length == 0
+  end
+  
+  def entry_resolved?(entry_name)
+    return !entry_name.is_a?(String)
+  end
+  
+  def resolve_entry(entry_name)
+    return @resolver.resolve(entry_name)
+  end
+  
+  def resolve
+    until @unresolved.empty?
+      entry_name = @unresolved.pop
+      entry = resolve_entry(entry_name)
+      
+      raise "entry '#{entry_name}' could not be resolved" if entry.nil?
+      @resolved << entry
+    end
+  end
+  
+  def each(&block)
+    resolve
+    @resolved.each(&block)
+    return nil
+  end
+  
+  def collect(&block)
+    resolve
+    @resolved.collect(&block)
+  end
+  
+  def to_a
+    resolve 
+    return @resolved.clone
+  end    
+  alias :to_ary :to_a
+end

data/lib/filament/workspace.rb

@@ -0,0 +1,57 @@
+require 'pathname'
+
+require 'filament/package'
+require 'filament/resolver'
+
+module Filament
+  class Workspace
+    attr_reader :package_resolver, :realpath
+    
+    def initialize(path)
+      @realpath = Pathname.new(path).realpath
+      # stores Pathname#realpath for all packages in this workspace
+      @realpath_package_cache = {}
+      
+      @package_resolver = PackageResolver.new
+      
+      # create root_package for this workspace
+      @root_package = Package.new(
+        :realpath => @realpath, 
+        :parent => nil,
+        :workspace => self,
+        :package_resolver => @package_resolver)
+    end
+    
+    def package_for_realpath(realpath)
+      return nil if realpath.nil?
+      realpath_p = Pathname.new(realpath)
+      
+      raise "realpath must be absolute." unless realpath_p.absolute?
+      
+      if @realpath_package_cache.key?(realpath_p)
+        return realpath_package_cache[realpath_p]
+      end
+      
+      relative_path_p = realpath_p.relative_path_from(@realpath)
+      package = @root_package + relative_path_p
+      @realpath_package_cache[realpath_p] = package
+      
+      return package
+    end
+    
+    def resolve_package(uri)
+      @package_resolver.resolve_package(uri)
+    end
+    
+    def load_tasks(package=nil)
+      package ||= @root_package
+      
+      pn = package.pathname + 'tasks.rb'
+      load pn.realpath if pn.exist?
+
+      package.subpackages.each do |subpkg|
+        load_tasks(subpkg)
+      end
+    end
+  end
+end

data/lib/filament.rb

@@ -0,0 +1,199 @@
+require 'pathname'
+require 'set'
+
+# rake stuff
+begin
+  require 'rake'
+rescue LoadError
+  require 'rubygems'
+  require_gem 'rake'
+end
+require 'rake/clean'
+
+require 'filament/workspace'
+require 'filament/platform'
+require 'filament/plugins'
+require 'filament/package'
+require 'filament/target'
+require 'filament/artifact'
+
+require 'filament/util/filelist2'
+require 'filament/util/fileutils'
+
+module Filament
+  def log(msg)
+    puts msg if $verbose
+  end
+  
+  def verbose(on)
+    RakeFileUtils.verbose(false)
+    $verbose = on
+#     if on
+#       trace_var :$context, lambda { |c| 
+#         puts "$context is now #{c}" 
+#       }
+#     else
+#       untrace_var :$context
+#     end
+  end
+  
+  $actions ||= []
+  
+  class Application
+    OPTIONS = [ 
+    ['--trace', '-t', GetoptLong::NO_ARGUMENT, 
+        "Turn on invoke/execute tracing"],
+    ]
+    
+    TARGET_ACTIONS = {
+      :build => Proc.new { |targets|
+        targets.each { |target| target.build }
+      },
+      :clobber => Proc.new { |targets|
+        targets.each { |target| target.package.clobber }
+      },
+      :execute => Proc.new { |targets|
+        targets.each do |target|
+          target.build
+          block = target[:execute]
+          target.package.build_context.execute(&block) unless block.nil?
+        end
+      },
+    }
+    
+    PACKAGE_ACTIONS = {
+      
+    }
+    
+    def collect_other_args
+      targets = []
+      packages = []
+      actions = []
+      vars = {}
+      ARGV.each do |arg|
+        if arg =~ /^(\w+)=(.*)$/
+          vars[$1] = $2
+        elsif arg =~ /^[^\/^:]/
+          actions << arg.to_sym
+        else
+          targets << arg
+          if arg =~ /^\/[^:]/
+            packages << arg
+          end
+        end
+      end
+      return { :vars => vars,
+               :targets => targets,
+               :packages => packages,
+               :actions => actions }
+    end
+    
+    def do_option(opt, value)
+      case opt
+      when '--trace'
+        $trace = true
+        verbose(true)
+      else
+        fail "Unknown option: #{opt}"
+      end
+    end
+    
+    def command_line_options
+      OPTIONS.collect { |lst| lst[0..-2] }
+    end
+    
+    def handle_options
+      opts = GetoptLong.new(*command_line_options)
+      opts.each { |opt, value| do_option(opt, value) }
+    end
+    
+    def run(&block)
+      verbose(false)
+
+      handle_options
+      
+      begin
+        other_args = collect_other_args
+        vars = other_args[:vars]
+        
+        vars.each do |key, val|
+          ENV[key] = val
+        end
+        
+        actions = $actions + other_args[:actions]
+        actions.compact!
+        
+        workspace_path = ENV['WR'] || Filament::find_dir(Pathname.pwd, '.workspace')
+        $workspace = Workspace.new(workspace_path)
+        $target_platform = (ENV['TARGET_PLATFORM'] || :mpp_sdk || :i860 || :wt2_2).to_sym
+
+        build_type = (ENV['BUILD_TYPE'] || :DBG).to_sym
+        dirs = { :TEST => 'test', 	# this is a folder for testing targets to use 
+                 :DBG  => 'dbg',	# final jars, binaries, etc. are placed in these
+                 :OPT  => 'opt' } 	# this is for obfuscated, compressed, releasable versions
+
+        raise "unknown build type: '#{build_type}'" unless dirs.key?(build_type) 
+          
+        $build_dir_prefix = "#{dirs[build_type]}/#{$target_platform.to_s}"
+
+        pn = Pathname.new(__FILE__).parent.parent + 'plugins'
+        Filament::load_plugins(pn.realpath)
+
+        $workspace.load_tasks
+        this_package = $workspace.package_for_realpath(Pathname.pwd.realpath)
+        
+        this_package.execute do
+          targets = TargetList.new(*other_args[:targets])
+          packages = PackageList.new(*other_args[:packages])
+        
+          if targets.empty?
+            log "assuming default target of '#{this_package.uri}'"
+            targets.include(this_package.uri) 
+          end
+        
+          if packages.empty?
+            log "assuming default package of '#{this_package.uri}'"
+            packages.include(this_package.uri)
+          end
+        
+          if block.nil?
+            target_blocks = []
+            package_blocks = []
+          
+            actions.each do |action|
+              if TARGET_ACTIONS.key?(action)
+                target_blocks << TARGET_ACTIONS[action]
+              elsif PACKAGE_ACTIONS.key?(action)
+                package_blocks << PACKAGE_ACTIONS[action]
+              else
+                raise "Unknown action: #{action}"  
+              end
+            end
+            
+            # some debug
+            root_packages = $context[:package_resolver].root_packages.collect { |p| p.full_name }
+            puts "ACTIONS:      #{actions.join(', ')}"
+            puts "PACKAGE_RESOLVER:   #{root_packages.join(', ')}"
+
+            target_blocks.each { |b| b.call(targets) }
+            package_blocks.each { |b| b.call(packages) }
+          else
+            targets.each(&block)
+          end
+        end
+      rescue Exception => ex
+        puts "Build aborted!"
+        puts ex.message
+        if $trace
+          puts ex.backtrace.join("\n")
+        else
+          puts ex.backtrace.find {|str| str =~ /rakefile.rb/ } || ""
+        end
+        exit(1)
+      end
+    end
+  end
+end
+
+include Filament::Platform
+include Filament