filament 0.1.0

data/README

@@ -0,0 +1,7 @@
+Filament is a new spin on an old idea. Combine dependency-resolution, lazy-binding and rake (a ruby-based make alternative) and you get filament. Filament workspaces are a simple, cross-platform approach to managing complex build needs.
+
+I created it satisfy my needs as a mobile application developer.
+
+I am currently managing 20 inter-dependent libraries for a suite of JavaME platforms using only filament, its stock plugins, and minor dependencies.
+
+This tool has been developed and tested on Ruby 1.8.4, Rake 0.7, Cygwin (XP sp2), OS X 10.4.5, and Gentoo Linux.

data/bin/filament

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+
+#load "#{ENV['WR']}/tools/filament/lib/filament.rb"
+require 'filament'
+
+if FileTest.symlink?($0)
+  $actions << File.basename($0).to_sym
+end
+
+Filament::Application.new.run
+

data/bin/filament-dbg

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+build BUILD_TYPE=DBG $@

data/bin/filament-opt

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+build BUILD_TYPE=OPT $@

data/bin/filament-test

@@ -0,0 +1,3 @@
+#!/bin/bash
+
+build BUILD_TYPE=TEST test $@

data/bin/init

@@ -0,0 +1,4 @@
+#!/bin/bash
+
+export BUILD_PLUGINS=${BUILD}/plugins
+#export PATH=`ls -1 ${BUILD_PLUGINS} | xargs -I qq echo -n "${BUILD_PLUGINS}/qq/script:"`${PATH}

data/lib/filament/artifact.rb

@@ -0,0 +1,49 @@
+require 'filament/package'
+require 'filament/target'
+
+module Filament
+  class Artifact < Target
+    attr_reader :directories, :name
+    attr_accessor :weak_deps, :deps, :package
+    
+    def initialize(name, &block)
+      @directories = []
+      @tasks = []
+
+      super(:name => name) do
+        build_artifact
+      end
+
+      init
+      instance_eval(&block)
+    end
+    
+    def init; end
+    
+    def working_dir
+      return "#{$context[:working_dir]}/#{package.path}/#{name}"
+    end
+    
+    def output_dir
+      return "#{$context[:output_dir]}/#{package.path}"
+    end
+    
+    alias :orig_directory :directory
+    def directory(path, is_working_dir=true)
+      path = "#{working_dir}/#{path}" if is_working_dir
+      @directories << path
+      orig_directory(path)
+      return path
+    end
+        
+    def invoke_tasks
+      # make output directory
+      mkdir_p(output_dir) unless File.exist?(output_dir)
+
+      # invoke them all
+      @tasks.each do |t|
+        t.invoke
+      end
+    end
+  end
+end

data/lib/filament/context.rb

@@ -0,0 +1,46 @@
+require 'fileutils'
+require 'filament/package'
+
+module Filament
+  class ExecutionContext
+    attr_reader :wrapper
+    
+    def initialize(package)
+      @package = package
+      raise "package cannot be nil" if @package.nil?
+      
+      @context = {}
+      @context[:context] = self
+      @context[:this_package] = @package
+      @context[:package_resolver] = @package.package_resolver
+      @context[:target_resolver] = @package.target_resolver
+    end
+  
+    def wrap(*args, &block)
+      execute do
+        wrapper = Module.new
+        wrapper.instance_eval(*args, &block)
+      end
+    end
+    
+    def execute(&block)
+      $context ||= Hash.new {|hash, key| raise "unknown context variable: #{key}"}
+      
+      _context = $context.clone
+      $context.merge!(@context)
+
+      FileUtils.cd(@package.pathname, &block)
+
+      $context = _context
+    end
+  end
+  
+  class BuildContext < ExecutionContext
+    def initialize(package)
+      super(package)
+    
+      @context[:working_dir] = @package.working_dir
+      @context[:output_dir] = @package.output_dir
+    end
+  end
+end

data/lib/filament/package/svn.rb

@@ -0,0 +1,123 @@
+require 'filament/package'
+
+module Filament
+  class Package    
+      # returns true if this package is under svn control
+      def svn?
+        p = @pathname + '.svn'
+        return p.exist?
+      end
+
+      def revision
+        return svn_revision
+      end
+
+      def update
+        return svn_update
+      end
+
+      def status
+        return svn_status
+      end
+
+      def commit(msg)
+        return svn_commit(msg)
+      end
+
+      def svn_info
+        stream = IO.popen("svn info #{@pathname.realpath}")
+        return YAML.load(stream)
+      end
+
+      def svn_revision
+        return 0 unless svn?
+        return svn_info['Last Changed Rev'].to_i
+      end
+
+      def svn_url
+        return nil unless svn?
+        return svn_info['URL']
+      end
+
+      def svn_base_url
+        return url.gsub(/\/(trunk|branches\/[.^\/]*|tags\/[.^\/]*)$/, '')
+      end
+
+      # if this package is under version control, it will update it
+      # if this package has subpackages, it will update them
+      def svn_update
+        if svn?
+          puts full_name
+          system('svn update')
+        end
+        subpackages.each { |s| s.update }
+      end
+
+      # if this package is under version control, it will print its status
+      # if this package has subpackages it will print their status
+      def svn_status
+        if svn?
+          puts full_name
+          system('svn status')
+        end
+        subpackages.each { |s| s.status }
+      end
+
+      # if this package is under version control, it will commit it with the 
+      # given msg
+      # if this package has subpackages it will commit them
+      def svn_commit(msg)
+        if svn?
+          puts full_name
+          system("svn ci -m \"#{msg}\"") 
+        end
+        subpackages.each { |s| s.commit(msg) }
+      end
+    end
+
+    def self.build_uri(h)
+      uri = h[:uri]
+
+      return uri unless @uri.nil?
+
+      package_path = h[:package_path]
+      base_uri = h[:root_uri] || ENV['BASE_SVN_URL']
+
+      tag = h[:tag]
+      branch = h[:branch]
+
+      return "#{base_uri}/tags/#{package_path}/#{tag}" unless tag.nil?
+      return "#{base_uri}/branches/#{package_path}/#{branch}" unless branch.nil?
+      return "#{base_uri}/trunk/#{package_path}"
+    end
+
+    # checks out the package into the current wd (preserving its path)
+    def self.checkout(h)
+      uri = Package.build_uri(h)
+      pkg = Package.create(h)
+      pkg.system("svn co #{uri} .")
+      return pkg
+    end
+
+    # exports a url to a given dir
+    def self.export(h)
+      uri = Package.build_uri(h)
+      pkg = Package.create(h)
+      pkg.system("svn export #{uri} .")
+      return pkg
+    end
+
+  end
+end
+
+
+#class URI::Generic
+#  def to_package
+#    s = SVN.new(uri)
+#    raise "not an svn uri" unless s.valid?
+#    pkg = export(:package_path => s.path,
+#                 :uri => s.uri,
+#                 :root_dir => Filament::Package.CACHE_DIR)
+#    return pkg
+#  end
+#end

data/lib/filament/package.rb

@@ -0,0 +1,326 @@
+require 'fileutils'
+require 'pathname'
+require 'yaml'
+require 'open-uri'
+
+require 'filament/util/fileutils'
+require 'filament/util/lazy_list'
+
+require 'filament/context'
+
+module Filament
+  class PackageList < LazyList
+    def initialize(*args)
+      @resolver = $context[:package_resolver]
+      super(*args)
+    end
+  end
+  
+  class Package
+    attr_reader :parent, :name, :realpath, :workspace, :package_resolver, :target_resolver, :build_context
+    alias :pathname :realpath
+    
+    def initialize(h)
+      @parent = h[:parent]
+      @workspace = h[:workspace]
+      
+      
+      if @workspace.nil?
+        unless @parent.nil?
+          @workspace = @parent.workspace
+        else
+          raise "all packages must belong to a workspace"
+        end
+      end
+
+      @package_resolver = h[:package_resolver] || PackageResolver.new(@workspace.package_resolver)
+
+      @name = h[:name]
+      @realpath = h[:realpath]
+      
+      @subpackage_cache = {}
+      
+      if @realpath.nil?
+        raise "package must have a name." if @name.nil?
+        raise "package must have a parent." if @parent.nil?
+        
+        @realpath = @parent.realpath + @name
+      else
+        raise "package must not have a name." unless @name.nil?
+        raise "package must not have a parent." unless @parent.nil?
+
+        @realpath = Pathname.new(@realpath)
+        raise "realpath must be absolute" unless @realpath.absolute?
+      end
+      
+      @descriptor_loaded = false
+      
+      @targets = {}
+      @target_resolver = TargetResolver.new(self)
+
+      # add the "cache" directory for this package
+      @package_resolver << youngest_root_package.subpackage('cache')
+      # add the root directory for the current package to the list of search directories
+      @package_resolver << youngest_root_package
+      # add the "vendor" directory for this package
+      @package_resolver << subpackage('vendor')      
+
+      @execution_context = ExecutionContext.new(self)
+      @build_context = BuildContext.new(self)
+    end
+    
+    def exist?
+      return @realpath.exist?
+    end
+
+    def workspace?
+      p = @realpath + '.workspace'
+      return p.exist?
+    end
+    
+    # returns true if this package is a root package.
+    # a root package is one that has a .root file.
+    def root?
+      return true if workspace?
+      p = @realpath + '.root'
+      return p.exist?
+    end
+    
+    # returns true if this is root package or if one of its parents is
+    def has_valid_root?
+      return true if root?
+      return @parent.has_valid_root?
+    end
+    
+    def youngest_root_package
+      return self if root?
+      return @parent.youngest_root_package
+    end
+    
+    # returns true if this package is a parent package
+    # a parent package is one that is a root or has a .parent file
+    def parent?
+      return true if root?
+      p = @realpath + '.parent'
+      return p.exist?
+    end
+
+    # returns true if:
+    # 1. its parent thinks its a parent
+    # 2. its parent has a valid root
+    def has_valid_parent?
+      # should have a valid root
+      return false unless has_valid_root?
+      
+      # roots shouldn't have parents
+      return @parent.nil? if root?
+      
+      # everything else should
+      return false unless @parent.parent?
+      
+      # walk up
+      return @parent.has_valid_parent?
+    end
+    
+    # returns true if:
+    # 1. this package refers to a directory that exists
+    # 2. this package has a valid parent
+    def valid?
+      return false unless exist? and @pathname.directory?
+      return has_valid_parent?
+    end
+    
+    def disabled?
+      p = @realpath + '.disabled'
+      return true if p.exist?
+      if root?
+        return false
+      else
+        return @parent.disabled?
+      end
+    end
+    
+    def make_root!
+      return if root?
+      raise "won't convert parent to root" if parent?
+      touch(@realpath + '.root')
+    end
+    
+    # if this package is not yet a parent, it will mark it as one
+    def make_parent!
+      return if parent?
+      return make_root! if @parent.nil?
+      touch(@realpath + '.parent')
+    end
+    
+    def make_valid!
+      return if valid?
+
+      p = @parent
+      until p.nil?
+        p.make_parent!
+        p = p.parent
+      end
+      
+      mkdir(@realpath) unless exist?
+      return nil
+    end
+    
+    # returns the full name of the package
+    def uri
+      return '//' + path
+    end
+    alias :full_name :uri
+    
+    # returns the path of the package (from the root_dir)
+    def path
+      return '' if workspace?
+      return @name if @parent.workspace?
+      return @parent.path + '/' + @name
+    end
+
+    # returns a list of subpackages. [] is returned if there are none.
+    def subpackages(include_disabled = false)
+      return [] unless parent?
+
+      children = @realpath.children.reject { |child| !child.directory? }
+
+      children.collect! do |child|
+        subpackage(child.basename.to_s)
+      end
+      
+      unless include_disabled
+        children.reject! { |child| child.disabled? }
+      end
+      
+      return children 
+    end
+    
+    # returns a Package object for the subpackage with the given name
+    # NOTE: a Package is returned, even when this package is not a valid parent
+    # or this package doesn't exist
+    def +(subpackage_name)
+      if subpackage_name.respond_to?(:to_ary)
+        name_stack = subpackage_name.to_ary
+      elsif subpackage_name.respond_to?(:to_s)
+        name_stack = subpackage_name.to_s.split(/\//).reverse
+      else
+        raise "illegal argument. only string or array is allowed here."
+      end
+      
+      sub_name = name_stack.pop
+      
+      if @subpackage_cache.key?(sub_name)
+        sub = @subpackage_cache[sub_name]
+      else
+        sub = Package.new(:name => sub_name, :parent => self)
+        @subpackage_cache[sub_name] = sub
+      end
+      
+      if name_stack.empty?
+        return sub
+      else
+        return sub + name_stack
+      end
+    end
+    
+    # returns nil if there is no such subpackage or 
+    # the subpackage with the given name
+    def subpackage(subpackage_name)
+      return nil unless parent?
+      
+      child = @realpath + subpackage_name
+      if child.exist?
+#         log "child found: #{subpackage_name} (#{child}) in #{full_name}"
+        return self + subpackage_name
+      else
+#         log "child not found: #{subpackage_name} (#{child}) in #{full_name}"
+        return nil 
+      end
+      
+    end
+    
+    ### Recursive package operations
+    def list
+      subpackages.each do |s|
+        puts s.uri
+      end
+    end
+
+    # executes cmd with this packages as the wd, and with $this_package set to self
+    def execute(&block)
+      @execution_context.execute(&block)
+    end
+    
+    @@orig_system = Kernel.method :system
+    def self.orig_system(*args); @@orig_system.call(*args); end
+    
+    # executes cmd with this package as the wd
+    def system(cmd)
+      execute do |dir|
+        raise "error executing '#{cmd}' in #{dir}" unless Package.orig_system(cmd)
+      end
+    end
+
+    ### Target-related stuff  
+    def descriptor_loaded?
+      return @descriptor_loaded
+    end
+  
+    def descriptor
+      return "#{@realpath}/rakefile.rb"
+    end
+  
+    def << (target)
+      @targets[target.name.to_sym] = target
+      return self
+    end
+  
+    def load
+      return if descriptor_loaded?
+      @descriptor_loaded = true
+
+      pn = Pathname.new(descriptor)
+      unless pn.exist?
+        return if parent?
+        raise "package descriptor for #{@realpath} does not exist '#{pn}'"
+      end
+      
+      @execution_context.wrap(pn.read, pn.realpath)
+    end
+  
+    def target_dir(subdir=nil)
+      pn = @realpath + 'target'
+      
+      unless subdir.nil?
+        pn += "#{subdir}/#{$build_dir_prefix}" 
+      end
+      
+      mkdir_p(pn) unless pn.exist?
+      return pn.realpath
+    end
+    
+    def working_dir
+      target_dir('tmp')
+    end
+    
+    def output_dir
+      target_dir('obj')
+    end
+  
+    def clobber
+      rm_rf(working_dir)
+      rm_rf(output_dir)
+    end
+  
+    def [](target_name)
+      load
+      return @targets[target_name.to_sym]
+    end
+  
+    def targets
+      load
+      return @targets.values
+    end
+  end
+end

data/lib/filament/platform.rb

@@ -0,0 +1,79 @@
+module Filament
+	module Platform
+	  TARGET_PLATFORMS = {}
+	    
+	  def darwin?
+	  	  return ! PLATFORM.index("darwin").nil?
+	  end
+	  
+	  def windows?
+	    return cygwin?
+	  end
+	  
+	  def cygwin?
+	    return ! PLATFORM.index("cygwin").nil?
+	  end
+	  
+	  def sys(c)
+	    log c
+	    raise "!!! Error executing '#{c}'" unless system(c)
+	  end
+	  
+	  def to_unix_path(path)
+	    return nil if path.nil?
+	    if cygwin?
+	      return path unless /:\\/ === path
+	      drive, path = path.split(":\\", 2)
+	      path.gsub!(/\\/, '/')
+	      return "/cygdrive/#{drive}/#{path}"
+	    end
+	    return path 
+	  end
+	  
+	  def to_exec_path(path)
+      return nil if path.nil?    
+	    return to_unix_path(path) if cygwin?
+	    return path
+	  end
+	  
+	  def to_windows_path(path)
+      return nil if path.nil?
+	    if path.index('cygdrive').nil?
+	      puts "#{path}\n"
+	      return path
+	    end
+	    
+	    path = path.chomp.sub(/\/cygdrive\//, '')
+	    drive, path = path.split(/\//, 2)
+	  
+	    return "#{drive}:/#{path}"
+	  end
+	  
+	  def fix_paths(paths)
+	    return nil if paths.nil?
+	    
+	    if cygwin?
+	      paths = paths.to_a.collect do |path|
+	        to_windows_path(path)
+	      end
+	    end
+	    
+	    return paths.to_a
+	  end
+	  
+	  def join_paths(paths)
+	    return nil if paths.nil?
+	  
+	    if windows?
+	      joined = fix_paths(paths).join(';')
+	      return "'#{joined}'"
+	    end
+	  
+	    return fix_paths(paths).join(':')
+	  end
+	  
+	  alias :u :to_unix_path
+	  alias :w :to_windows_path
+	  alias :fix :fix_paths
+	end
+end

data/lib/filament/plugins.rb

@@ -0,0 +1,32 @@
+module Filament
+  def self.get_plugin_dirs(path)
+    pn = Pathname.new(path)
+    return pn.children.sort  
+  end
+  
+  def self.load_plugins(plugin_base_dir)
+    update_env(plugin_base_dir)
+
+    plugins = []
+    dirs = get_plugin_dirs(plugin_base_dir)
+    dirs.each do |child|      
+      ln = child + 'lib'
+      
+      if ln.exist?
+        $LOAD_PATH << ln.realpath
+        cn = ln + 'init.rb'
+        raise "cannot init filament plugin '#{child}'" unless cn.exist?
+        load cn.realpath
+        plugins << child.basename.to_s
+      end
+    end
+    
+    puts "PLUGINS: #{plugins.join(', ')}"
+  end
+
+  def self.update_env(plugin_base_dir)
+    plugin_dirs = get_plugin_dirs(plugin_base_dir)
+    script_dirs = plugin_dirs.collect {|dir| dir + 'script' }
+    ENV['PATH'] = script_dirs.join(':') + ':' + ENV['PATH']
+  end
+end