filament 0.3.0 → 0.4.0

data/CHANGES

@@ -0,0 +1,96 @@
+0.4.0:
+	Filament:
+	  * LazyList accepts multiple arguments, instead of requiring an array
+	  * [FIXED] BUILDING message is now accurate
+	  * Added task command to execute a rake task, after invoking the given targets
+	  * Added on_define method to Target, its instances, and all subclasses
+	  * Added tag.tag_name support for conditional definitions
+	  * Added options hash to all targets
+	  * Added src_dir function
+	  * Moved all platform code to Filament, out of JavaME Plugin
+	  * [FIXED] FileList2 bug with 'include' on Arrays
+	Spin Plugin:
+	  * java_method accepts a trailing hash, for cleaner files  
+	  * java_member now implemented
+	  * added java_class to complement spin_prototype
+	
+0.3.0:
+  Filament:
+    * Updated Target#output to optionally take a block as output value
+    * Renamed Scm => SCM
+    * Created CompoundSCM to manage many SCMs
+    * Moved Filament::Platform module to Filament::OS
+    * Created Platform class, to manage platforms * use Platform.import(<yaml>)
+    * Replaced Artifact with Target
+    * FileList2 now has a tag attribute, allowing to set the tag it uses to resolve targets
+    * Added dependence on mechanize gem
+    * [FIXED] create scms with realpath, not package
+  HTTP Plugin:
+    * Uses mechanize to crawl a page for links
+    * Added plugin to manage pulling stuff from the web
+    * Future support may include pushing stuff to the web (over webdav)
+  Spin Plugin:
+    * Added libs for generating sji (both java and spin) interfaces
+    * creates a target with :java and :spin source outputs
+    * outputs a jad_proc to add entries for interpreter startup
+  Java Plugin:
+    * Dropped use of JAVAC, JAR, etc. to just use java_bin('javac'), etc.
+  JavaME Plugin:
+    * Merged Library and Suite functionality into a single rake tasklib
+    * Simplified Library and Suite artifacts
+
+0.2.3:
+  SVN Plugin:
+	  * Fixed an svn include problem
+	  * Fixed the svn commands to work with new package.scm
+
+0.2.2:
+  Filament:
+    * Fixed handling for scm actions for packages without scm
+
+0.2.1:
+  Filament:
+    * Added ability to create workspace, package
+    * Added ability to checkout (and create) a package
+    * Can now execute the filament command outside a workspace
+    * Moved svn parts to PackageScm
+    * Supports in place to work with other forms of version control
+
+0.2.0:
+  Filament:
+    * removed old tests
+    * Using cmdparse gem; One action per command
+    * added dependency on memoize gem
+    * general cleanup
+  All Plugins:
+    * Plugins now extend Filament::Plugin where necessary
+  JavaME Plugin:
+    * Moved vendor-specific stuff to tasks.rb in //vendor/libraries/javame 
+  SVN Plugin:
+    * Created svn plugin, should make it easier to support other version control schemes in the future
+
+0.1.2:
+  JavaME Plugin:
+    * Changed the default for obfuscating JavaME::Suite targets to false.
+
+0.1.1:
+  Filament:
+    * Packages can't be hidden directories now
+    * Doesn't force working_dir and output_dir creation
+    * Package descriptor is now /package.rb instead of rakefile.rb
+    * package.rb is now evaluated within the scope of the Package object. 
+    * targets are now defined by target(name, class, &block)
+    * future cleanups code cleanups will benefit from the two above items.
+  All Plugins:
+    * Updated external path references (Wtk, MppSdk, Proguard classes) to only use ENV
+    * Added ENV support for WTK_HOME, MPP_SDK_HOME, PROGUARD_HOME
+  Java Plugin:
+     * Added support for Proguard obfuscation
+     * Targets can output a 1-argument-block tagged :proguard and configure the obfuscator for dependencies
+  JavaME Plugin:
+     * Suite now takes itself into account when traversing deps for :jad_config outputs
+     * Obfuscation is available if you set obfuscate to true -- will auto-detect in the future
+
+0.1.0:
+  Filament:
+    * Initial Release

data/README

@@ -1,7 +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.
+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.
+I am currently managing a number of 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/lib/filament.rb

@@ -92,7 +92,7 @@ module Filament
     def initialize
       @cmd = CmdParse::CommandParser.new(true)
       @cmd.program_name = "filament"
-      @cmd.program_version = [0, 3, 0]
+      @cmd.program_version = [0, 4, 0]
       @cmd.add_command(CmdParse::HelpCommand.new)
       @cmd.add_command(CmdParse::VersionCommand.new)
       @cmd.options = CmdParse::OptionParserWrapper.new do |opt|

data/lib/filament/block_object.rb

@@ -0,0 +1,11 @@
+module Filament
+  class BlockObject
+    def initialize(&p)
+      @proc = p
+    end
+    
+    def method_missing(sym, *args, &p)
+      @proc.call(sym, args, p)
+    end
+  end
+end

data/lib/filament/os.rb

@@ -1,6 +1,4 @@
 module Filament::OS
-  TARGET_PLATFORMS = {}
-  
   def darwin?
 	  return ! PLATFORM.index("darwin").nil?
   end
@@ -38,7 +36,6 @@ module Filament::OS
   def to_windows_path(path)
     return nil if path.nil?
     if path.index('cygdrive').nil?
-      puts "#{path}\n"
       return path
     end
   

data/lib/filament/platform.rb

@@ -1,6 +1,8 @@
 require 'yaml'
 
 module Filament
+  TAGS = {}
+  
   class Platform
     def self.property(*attrs)
       attrs.each do |a|
@@ -69,6 +71,20 @@ module Filament
       return @prototypes.collect {|p| Platform.find(:name => p)}
     end
   
+    def classpath
+      base_classpath = @attributes[:classpath]
+
+      classpath = []
+      classpath += base_classpath unless base_classpath.nil?
+
+      tags.each do |tag|
+        tag_classpath = TAGS[tag]
+        classpath += tag_classpath unless tag_classpath.nil?
+      end
+
+      return classpath
+    end
+  
     private
     def initialize(name, prototypes, attributes)
       @name = name

data/lib/filament/resolver.rb

@@ -48,9 +48,10 @@ module Filament
       @package_resolver = @package.package_resolver
     end
 
-    def valid_uri?(path)
+    def valid?(path)
       return FULL_REGEX === path || TARGET_REGEX === path || PACKAGE_REGEX === path
     end
+    alias :valid_uri? :valid?
     
     def resolve(uri)
       package_path = nil

data/lib/filament/target.rb

@@ -1,4 +1,5 @@
 require 'filament/util/lazy_list'
+require 'set'
 
 module Filament
   class TargetList < LazyList
@@ -8,8 +9,44 @@ module Filament
     end
   end
   
+  module SrcUtil
+      def files(h)
+      tags = h[:tags]
+      suffix = h[:suffix] || '.*'
+      dir = h[:dir] || "#{h[:base_dir]}/#{h[:sub_dir]}"
+      wildcard = h[:wildcard] || "**/*#{suffix}"
+      
+      list = []
+      p = Pathname.new(dir)
+      if p.exist?
+        p.children.each do |child|
+          if tags.include?(child.basename.to_s.to_sym)
+            list += FileList[child + wildcard].to_a
+          end
+        end
+      end
+
+      return list
+    end
+    
+    def src_files(h)
+      h[:base_dir] ||= 'src'
+      h[:tags] ||= platform.tags + [:all]
+      return files(h)
+    end
+    
+    def res_files(h)
+      h[:sub_dir] ||= 'res'
+      return src_files(h)
+    end
+    
+    def src_dir(dir)
+      return src_files(:dir => dir)
+    end
+  end
+  
   class Target
-    attr_reader :name, :package, :weak_deps, :deps, :deployables
+    attr_reader :name, :package, :weak_deps, :deps, :deployables, :platform, :tag
     
     def initialize(args, &block)
       if args.is_a? Hash
@@ -30,28 +67,92 @@ module Filament
       @invoked = false
       @proc = Proc.new {}
       @outputs = {}
-      @deployables = []
-      
+      @options = {}
+      @deployables = Set.new
+      @on_define_procs = []
+      @on_init_procs = []
+
+      @platform = Filament::Platform.find(:name => $target_platform)
+      @tag = Filament::BlockObject.new do |sym, a, p| 
+        tags = @platform.tags
+        if tags.member?(sym)
+          p.call unless p.nil?
+        end
+        
+        tags.member?(sym)
+      end
+
       raise 'targets must have a name' if @name.nil?
       raise 'targets must have a package' if @package.nil?
       
-      @package << self       
-
+      @package << self
       init
       
       @proc = Proc.new do 
         instance_eval(&block)
-        define
+        on_init
+        on_define
+      end
+    end
+        
+    def assert_tag(*tags)
+      tags -= platform.tags
+      raise "target #{uri} requires platform tags: #{tags.join(', ')}" unless tags.empty?
+    end
+    
+    def options(h=nil)
+      return @options if h.nil?
+      @options.merge!(h)
+    end
+    
+    def on_define(&block)
+      unless block.nil?
+        @on_define_procs << block
+      else
+        @on_define_procs.each { |p| p.call(self) }
+        self.class.on_define(self)
       end
     end
     
-    def init; end
+    def self.on_define(target=nil, &block)
+      @@on_define_procs ||= {}
+      @@on_define_procs[self] ||= []
+
+      unless block.nil?
+        raise "if a block is given, target cannot be specified" unless target.nil?
+        @@on_define_procs[self] << block
+      else
+        raise "if a block is not given, target cannot be nil" if target.nil?
+        superclass.on_define(target) if superclass.respond_to?(:on_define)
+        @@on_define_procs[self].each{ |p| p.call(target) }
+      end
+    end
     
-    def define; end
+    def on_init(&block)
+      unless block.nil?
+        @on_init_procs << block
+      else
+        @on_init_procs.each { |p| p.call(self) }
+        self.class.on_init(self)
+      end
+    end
+    
+    def self.on_init(target=nil, &block)
+      @@on_init_procs ||= {}
+      @@on_init_procs[self] ||= []
 
+      unless block.nil?
+        raise "if a block is given, target cannot be specified" unless target.nil?
+        @@on_init_procs[self] << block
+      else
+        raise "if a block is not given, target cannot be nil" if target.nil?
+        superclass.on_init(target) if superclass.respond_to?(:on_init)
+        @@on_init_procs[self].each{ |p| p.call(target) }
+      end
+    end
+    
     def working_dir(subdir=nil)
       base = "#{$context[:working_dir]}/#{package.path}/#{name}"
-      
       return subdir.nil? ? base : "#{base}/#{subdir.to_s}"
     end
     
@@ -85,6 +186,13 @@ module Filament
       return fd
     end
     
+    def collect_outputs(tag)
+      o = flattened_deps.collect{|dep| dep[tag]}
+  	  o << self[tag]
+  	  o.compact!
+      return o
+    end
+    
     # adds some :output to the given :tag
     # if a block is given, assume that's the output
     # if :deployable is true, also adds :output to deployables
@@ -139,9 +247,9 @@ module Filament
         @weak_deps.each {|t| t.invoke}
         @deps.each {|t| t.invoke}
 
-        puts ">>> BUILDING #{uri} (#{@package.pathname}, #{self})"
         instance_eval(&@proc)
         
+        puts ">>> BUILDING #{uri} (#{@package.pathname}, #{self})"
         @outputs.values.select{|h| h.key?(:tasks)}.collect{|h| h[:tasks]}.each do |tasks|
           tasks.each do |t|
             t.invoke

data/lib/filament/util/filelist2.rb

@@ -16,7 +16,7 @@ module Filament
       files = []
       entries.each do |entry|
         if entry.respond_to? :to_ary
-          resolve_filament_uris(*entry.to_ary)
+          files += resolve_filament_uris(*entry.to_ary)
         else
           if @target_resolver.valid_uri?(entry)
             target = @target_resolver.resolve(entry)

data/lib/filament/util/lazy_list.rb

@@ -12,16 +12,16 @@ class LazyList
     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
+  def include(*entry_names)
+    entry_names.each do |entry_name|
+      if entry_name.respond_to?(:to_ary)
+        self.include(*entry_name.to_ary)
       else
-        @unresolved << entry_name
+        if entry_resolved?(entry_name)
+          @resolved << entry_name
+        else
+          @unresolved << entry_name
+        end
       end
     end
     return self

data/plugins/00util/lib/filament/plugins/util.rb

@@ -1,9 +1,26 @@
+require 'rake'
 require 'cmdparse'
 require 'filament/plugin'
 
 module Filament::Plugins
   class Util < Filament::Plugin
     def initialize(app)
+      app.subcommand('task', "Executes the given task") do |args|
+        resolver = $context[:target_resolver]
+        targets, tasks = args.partition { |arg| resolver.valid?(arg) } 
+        
+        targets = Filament::TargetList.new(targets)
+        
+        targets.each do |target| 
+          target.build do
+            target.invoke
+          end
+        end
+        
+        tasks.collect! { |task| Rake::Task[task] }
+        tasks.each { |task| task.invoke }
+      end
+      
       app.subcommand('build', "Build the given targets") do |args|
         targets = Filament::TargetList.new(*args)
         targets.each { |target| target.build }
@@ -24,6 +41,7 @@ module Filament::Plugins
         end
       end
       
+      
       app.subcommand('targets', "Shows targets of given package") do |args|
         packages = Filament::PackageList.new(*args)
         packages.each do |package|

data/plugins/01java/lib/filament/java/library.rb

@@ -0,0 +1,88 @@
+require 'filament/block_object'
+require 'filament/java/mixins/classpath'
+require 'filament/java/tasks/library_task'
+
+module Filament::Java
+  class Library < Filament::Target
+    include Filament::Java::Mixins::Classpath
+    include Filament::SrcUtil
+    
+    attr_accessor2 :obfuscate, :jvm_source_version, :jvm_target_version
+    
+    attr_writer :should_package_deps
+    attr_reader :srcs, :resources
+    
+    def custom_entries(h)
+      @custom_entries.merge!(h)
+    end
+    
+    def append_entries(h)
+      h.keys.each do |key|
+        @append_entries[key] ||= []
+        entry = h[key]
+        if entry.is_a?(Array)
+          @append_entries[key] += entry
+        else
+          @append_entries[key] << entry
+        end
+      end
+    end
+
+    def init
+      @append_entries = {}
+      @custom_entries = {}
+      
+      @srcs = Filament::FileList2.new
+      @srcs.tag = :java
+      
+      @resources = Filament::FileList2.new
+      @should_package_deps = false
+      
+      @bootclasspath = @platform.classpath || []
+      @custom_classpath = []
+
+      if tag.javame
+        @jvm_source_version = 1.2
+        @jvm_target_version = 1.2
+        @cldc_version = platform.javame_configuration_version
+        raise "cldc_version not defined for platform: #{platform.name}" if @cldc_version.nil?
+      end
+      
+      on_define do 
+        @library = Filament::Java::Tasks::LibraryTask.new do |l| 
+          define_library(l)
+        end
+    
+        task :build => @library.tasks
+    
+        output :tag => [:default, :jar], 
+               :output => @library.jar_path,
+               :deployable => true,
+               :tasks => @library.tasks
+        
+        output :tag => :append_entries,
+               :output => @append_entries
+        output :tag => :custom_entries,
+               :output => @custom_entries
+      end
+    end
+
+    def define_library(l)
+      l.working_dir = working_dir
+      l.output_dir = output_dir
+      l.name = name
+      l.classpath = classpath
+      l.should_preverify = tag.javame
+      l.jvm_source_version = @jvm_source_version
+      l.jvm_target_version = @jvm_target_version
+      l.cldc_version = @cldc_version
+      l.bootclasspath = @bootclasspath
+      l.srcs = @srcs + @deps.collect{ |d| d[:java] }.compact.flatten
+      l.resources = @resources + res_files(:wildcard => '*') + (@should_package_deps ? flattened_deps_jars : [])
+      l.task_deps << package.descriptor
+      l.proguard_proc = Proc.new do |o|
+        flattened_deps.collect{ |dep| dep[:proguard_proc] }.compact.each{|p| p.call(o)}
+      end
+    end
+  end
+end