filament 0.1.0

data/lib/inflector.rb

@@ -0,0 +1,124 @@
+# The Inflector transforms words from singular to plural, class names to table names, modularized class names to ones without,
+# and class names to foreign keys.
+module Inflector 
+  extend self
+
+  def pluralize(word)
+    result = word.to_s.dup
+
+    if uncountable_words.include?(result.downcase)
+      result
+    else
+      plural_rules.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }
+      result
+    end
+  end
+
+  def singularize(word)
+    result = word.to_s.dup
+
+    if uncountable_words.include?(result.downcase)
+      result
+    else
+      singular_rules.each { |(rule, replacement)| break if result.gsub!(rule, replacement) }
+      result
+    end
+  end
+
+  def camelize(lower_case_and_underscored_word)
+    lower_case_and_underscored_word.to_s.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+  end
+  
+  def underscore(camel_cased_word)
+    camel_cased_word.to_s.gsub(/::/, '/').gsub(/([A-Z]+)([A-Z])/,'\1_\2').gsub(/([a-z\d])([A-Z])/,'\1_\2').downcase
+  end
+
+  def humanize(lower_case_and_underscored_word)
+    lower_case_and_underscored_word.to_s.gsub(/_/, " ").capitalize
+  end
+
+  def demodulize(class_name_in_module)
+    class_name_in_module.to_s.gsub(/^.*::/, '')
+  end
+
+  def tableize(class_name)
+    pluralize(underscore(class_name))
+  end
+  
+  def classify(table_name)
+    camelize(singularize(table_name))
+  end
+
+  def foreign_key(class_name, separate_class_name_and_id_with_underscore = true)
+    Inflector.underscore(Inflector.demodulize(class_name)) + 
+      (separate_class_name_and_id_with_underscore ? "_id" : "id")
+  end
+
+  def constantize(camel_cased_word)
+    camel_cased_word.split("::").inject(Object) do |final_type, part| 
+      final_type = final_type.const_get(part)
+    end
+  end
+
+  private
+    def uncountable_words #:doc
+      %w( equipment information rice money species series fish )
+    end
+  
+    def plural_rules #:doc:
+      [
+      	[/^(ox)$/i, '\1\2en'],		             # ox
+      	[/([m|l])ouse$/i, '\1ice'],	           # mouse, louse
+      	[/(matr|vert)ix|ex$/i, '\1ices'],      # matrix, vertex, index
+        [/(x|ch|ss|sh)$/i, '\1es'],            # search, switch, fix, box, process, address
+        [/([^aeiouy]|qu)ies$/i, '\1y'],
+        [/([^aeiouy]|qu)y$/i, '\1ies'],        # query, ability, agency
+        [/(hive)$/i, '\1s'],                   # archive, hive
+        [/(?:([^f])fe|([lr])f)$/i, '\1\2ves'], # half, safe, wife
+        [/sis$/i, 'ses'],                      # basis, diagnosis
+        [/([ti])um$/i, '\1a'],                 # datum, medium
+        [/(p)erson$/i, '\1eople'],             # person, salesperson
+        [/(m)an$/i, '\1en'],                   # man, woman, spokesman
+        [/(c)hild$/i, '\1hildren'],            # child
+      	[/(buffal|tomat)o$/i, '\1\2oes'],		   # buffalo, tomato
+      	[/(bu)s$/i, '\1\2ses'],	               # bus
+        [/(alias)/i, '\1es'],                  # alias
+      	[/(octop|vir)us$/i, '\1i'],            # octopus, virus - virus has no defined plural (according to Latin/dictionary.com), but viri is better than viruses/viruss
+      	[/(ax|cri|test)is$/i, '\1es'],         # axis, crisis  
+        [/s$/i, 's'],                          # no change (compatibility)
+        [/$/, 's']
+      ]
+    end
+
+    def singular_rules #:doc:
+      [
+        [/(matr)ices$/i, '\1ix'],
+      	[/(vert)ices$/i, '\1ex'],
+      	[/^(ox)en/i, '\1'],
+      	[/(alias)es$/i, '\1'],
+      	[/([octop|vir])i$/i, '\1us'],
+      	[/(cris|ax|test)es$/i, '\1is'],
+      	[/(shoe)s$/i, '\1'],
+      	[/(o)es$/i, '\1'],
+      	[/(bus)es$/i, '\1'],
+      	[/([m|l])ice$/i, '\1ouse'],
+        [/(x|ch|ss|sh)es$/i, '\1'],
+        [/(m)ovies$/i, '\1\2ovie'],
+        [/(s)eries$/i, '\1\2eries'],
+        [/([^aeiouy]|qu)ies$/i, '\1y'],
+        [/([lr])ves$/i, '\1f'],
+        [/(tive)s$/i, '\1'],
+        [/(hive)s$/i, '\1'],
+        [/([^f])ves$/i, '\1fe'],
+        [/(^analy)ses$/i, '\1sis'],
+        [/((a)naly|(b)a|(d)iagno|(p)arenthe|(p)rogno|(s)ynop|(t)he)ses$/i, '\1\2sis'],
+        [/([ti])a$/i, '\1um'],
+        [/(p)eople$/i, '\1\2erson'],
+        [/(m)en$/i, '\1an'],
+        [/(s)tatus$/i, '\1\2tatus'],
+        [/(c)hildren$/i, '\1\2hild'],
+        [/(n)ews$/i, '\1\2ews'],
+        [/s$/i, '']
+      ]
+    end
+end

data/lib/svn.rb

@@ -0,0 +1,78 @@
+require 'yaml'
+require 'rubygems'
+require 'memoize'
+
+class SVN
+	include Memoize
+
+	attr_reader :uri
+	
+	def initialize(uri)
+		@uri = uri.gsub(/\/$/,'')
+
+		[:info, 'valid?'.to_sym, :ls].each do |m|
+			memoize(m)
+		end
+	end
+	
+	def valid?
+		return system("svn ls #{@uri} &> /dev/null")
+	end
+	
+	def tag
+		return @uri.match(/(.*)(\/tags)(\/[.^\/]*$)/)[1]
+	end
+	
+	def tag?
+		return !tag.nil?
+	end
+	
+	def branch
+		return @uri.match(/(.*)(\/branches)(\/[.^\/]*$)/)[1]
+	end
+	
+	def branch?
+		return !branch.nil?
+	end
+	
+	def trunk?
+		return !@uri.match(/(.*)(\/trunk$)/).nil?
+	end
+	
+	def info
+		info_p = IO.popen("svn info #{@uri}")
+		return YAML.load(info_p)
+	end
+	
+	def ls
+		return IO.popen("svn ls #{@uri}").readlines.collect do |s|
+			s.chomp
+		end
+	end
+	
+	def root
+		return info['Repository Root']
+	end
+	
+	def revision
+		return info['Revision']
+	end
+	
+	def name
+		return info['Name']
+	end
+	
+	def type
+		return info['Node Kind'].to_sym
+	end
+	
+	def path
+		return @uri.split("#{root}/").last
+	end
+	
+	def children
+		ls.collect do |child|
+			SVN.new("#{@uri}/#{child}")
+		end
+	end
+end

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

@@ -0,0 +1,47 @@
+class Filament::Util
+  package_actions = {
+    :list => Proc.new { |packages|
+      packages.each do |package|
+        package.list
+      end      
+    },
+    :update => Proc.new { |packages|
+      packages.each do |package|
+        package.update
+      end
+    },    
+    :status => Proc.new { |packages|
+      packages.each do |package|
+        package.status
+      end
+    },    
+    :commit => Proc.new { |packages|
+      packages.each do |package|
+        package.commit
+      end
+    },
+    #Display the targets and dependencies, then exit.
+    :targets => Proc.new { |packages|
+      packages.each do |package|
+        puts "  #{package.full_name}"
+        package.targets.each do |target|
+          puts "    #{target.uri}"
+        end
+      end
+    }
+  }
+  
+  target_actions = {
+    :prereqs => Proc.new { |targets|
+      targets.each do |target|
+        puts "    #{target.uri}"
+        target.deps.each do |dep|
+          puts "      #{dep.uri}"
+        end
+      end
+    }
+  }
+    
+  Application::PACKAGE_ACTIONS.merge!(package_actions)
+  Application::TARGET_ACTIONS.merge!(target_actions)
+end

data/plugins/01java/lib/filament/java/mixins/java_mixin.rb

@@ -0,0 +1,19 @@
+module Filament::Java::Mixins
+  module JavaMixin
+    def init_java
+    end   
+
+  	def classpath(target)
+  	  cp = @classpath
+      all_deps = TargetList.new
+      all_deps << target.flattened_deps
+      all_deps << target.weak_deps
+      all_deps.each do |d| 
+        jar = d[:jar]
+        # only add the jar if this dependecy has one
+        cp << jar unless jar.nil?
+      end
+      return cp
+    end
+  end
+end

data/plugins/01java/lib/filament/java/tools/compile.rb

@@ -0,0 +1,41 @@
+module Filament::Java::Tools
+	class Compile
+		attr_writer :sources, :output_dir, :source_version, :target_version,
+ 			          :classpath, :bootclasspath
+
+     def initialize(sources=[], output_dir=nil)
+	    init(sources, output_dir)
+      yield self if block_given?
+  	    compile unless @sources.empty? or @output_dir.nil?
+    end
+      
+	  # loads initial, default values
+	  def init(sources, output_dir)
+	    @sources = sources
+	    @output_dir = output_dir
+	    @bootclasspath = []
+	    @classpath = []
+	    @source_version = nil
+	    @target_version = nil
+	  end
+      
+	  # executes compile
+	  def compile
+	    classpath = join_paths(@classpath)
+	    bootclasspath = join_paths(@bootclasspath)
+	    output_dir = fix_paths(@output_dir)
+	    sources = fix_paths(@sources).join(' ')
+	    c = "#{JAVAC}"
+	    c << " -classpath #{classpath}" unless @classpath.empty?
+	    c << " -bootclasspath #{bootclasspath}" \
+	      unless @bootclasspath.empty?
+	    c << " -source #{@source_version}" unless @source_version.nil?
+	    c << " -target #{@target_version}" unless @target_version.nil?
+  
+	    c << " -d #{output_dir}"
+	    c << " #{sources}"
+			
+	    sys c
+	  end
+	end
+end

data/plugins/01java/lib/filament/java/tools/execute.rb

@@ -0,0 +1,37 @@
+module Filament::Java::Tools
+	class Execute
+	  attr_writer :classpath, :properties, :mainclass, :args
+	  
+	  def initialize(mainclass=nil)
+	    init(mainclass)
+	    yield self if block_given?
+	    execute unless @mainclass.nil?
+	  end
+	  
+	  def init(mainclass)
+	    @mainclass = mainclass
+	    @properties = {}
+	    @classpath = []
+	    @args = []
+	  end
+	  
+	  def execute
+	    c = "#{JAVA} "
+	    
+	    classpath = join_paths(@classpath)
+	    c << "-cp #{classpath} " unless classpath.nil?
+	    
+	    unless @properties.nil?
+	      @properties.each do |k,v|
+	        c << "-D#{k.to_s}=#{v.to_s} "
+	      end
+	    end
+	    
+	    c << @mainclass << " "
+	    
+	    c << @args.to_a.join
+	    
+	    sys c       
+	  end
+	end
+end

data/plugins/01java/lib/filament/java/tools/jar.rb

@@ -0,0 +1,59 @@
+module Filament::Java::Tools
+  class Jar
+    attr_writer :jar_file, :base_dir, :manifest, :index, :update
+    attr_accessor :package_files
+    
+    def initialize(jar_file=nil, base_dir=nil)
+      @jar_file = jar_file
+      @base_dir = base_dir
+      @package_files = []
+      @manifest = nil
+      @index = false
+      @update = false
+      
+      yield self if block_given?
+      
+      raise "jar_file cannot be nil." if @jar_file.nil?
+      
+      jar
+    end
+    
+    def jar
+      c = "#{JAR} "
+      c << 'v' if $verbose
+      c << 'f'
+      if @update
+        c << 'u'
+      else
+        c << 'c'
+      end
+      c << 'm' unless @manifest.nil?
+      c << " #{fix_paths(@jar_file)}"
+      c << " #{fix_paths(@manifest)}" unless @manifest.nil? or @manifest.empty?
+      c << " -C #{fix_paths(@base_dir)} ." unless @base_dir.nil?
+      c << " #{fix_paths(@package_files)}" unless @package_files.empty?
+      
+      sys c
+      
+      if @index
+        c = "#{JAR} i #{fix_paths(@jar_file)}"
+        sys c
+      end
+    end
+    
+    def self.extract(jar_file, output_dir)
+      cd output_dir do |dir|
+        if windows?
+          # using jar is too slow
+          c = "#{JAR} xf #{fix_paths(jar_file)}"
+          sys c
+        else
+          c = 'unzip '
+          c << '-q ' unless $verbose
+          c << "-o #{fix_paths(jar_file)}"
+          sys c
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'filament/platform'
+
+module Filament
+  module Java
+	  module Tools
+		  def self.bin(path=nil)
+		    java_home_env = ENV['JAVA_HOME']
+		    unless java_home_env.nil?
+		      java_bin = "#{java_home_env}/bin"  
+		      return java_bin if path.nil?
+		      return Filament::Platform.to_exec_path("#{java_bin}/#{path}")
+		    else
+		      # assume it's in the path
+		      return path
+		    end
+		  end
+
+			JAVAC = Tools.bin('javac')
+			JAVA  = Tools.bin('java')
+			JAR   = Tools.bin('jar')
+		end  
+	end
+end
+
+require 'filament/java/tools/jar'
+require 'filament/java/tools/execute'
+require 'filament/java/tools/compile'
+

data/plugins/01java/lib/init.rb

@@ -0,0 +1 @@
+require 'filament/java/tools'

data/plugins/02javame/lib/filament/javame/library.rb

@@ -0,0 +1,16 @@
+require 'filament/javame/mixins/library_mixin'
+
+module Filament::JavaME
+  class Library < Filament::Artifact
+    include JavaME::Mixins::LibraryMixin
+    
+    def init
+      init_library
+    end
+    
+    def build_artifact
+      define_library(self)
+      invoke_tasks
+    end
+  end
+end

data/plugins/02javame/lib/filament/javame/mixins/library_mixin.rb

@@ -0,0 +1,144 @@
+require 'filament/java/mixins/java_mixin'
+
+module Filament::JavaME::Mixins
+  module LibraryMixin
+    include Java::Mixins::JavaMixin
+    
+    attr_writer :package_deps
+    attr_reader :srcs, :resources, :manifest, :platform, :cldc_version
+    
+    def jar_path
+      return "#{output_dir}/#{@name}.jar"
+    end
+    
+    def init_library
+      init_java
+      @srcs = FileList2.new
+      @resources = FileList2.new
+      @manifest = nil
+      @package_deps = false
+      @platform = JavaME::Tools.tags_for($target_platform)
+      @cldc_version = JavaME::Tools.cldc_version_for($target_platform)
+      @bootclasspath = JavaME::Tools.classpath_for($target_platform)
+      @classpath = []
+
+      @append_entries = {}
+      @custom_entries = {}
+      
+      @jad_config = Proc.new do |d|
+        d.append_entries(@append_entries)
+        d.custom_entries(@custom_entries)
+      end
+    end
+    
+    def custom_entries(h)
+      h.keys.each do |key|
+        @custom_entries[key] = h[key]
+      end
+    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 define_library(target)
+      compiled_dir = directory(:compiled)
+      preverified_dir = directory(:preverified)
+      package_dir = directory(:package)
+      
+      cp = classpath(target)
+      # prune empty entries from src
+      @srcs.compact!
+      
+      if @package_deps
+        target.flattened_deps.each do |dep|
+          j = dep[:jar]
+          unless j.nil?
+            @resources.include(j)
+          end
+        end
+      end
+      
+      jar_deps = @srcs + @resources + directories + cp + @bootclasspath
+      
+      desc = target.package.descriptor
+      if File.exist?(desc)
+        jar_deps << desc
+      end
+      
+      unless @manifest.nil?
+        jar_deps += @manifest 
+      end
+      
+      jar_task = file(jar_path => jar_deps) do |t|
+        package_files = FileList.new
+        unless @srcs.empty?
+          # compile to the unverified directory
+          Java::Tools::Compile.new(@srcs, compiled_dir) do |c|
+            c.source_version = 1.2
+            c.target_version = 1.1
+            c.classpath = cp
+            c.bootclasspath = @bootclasspath
+          end
+          
+          # preverify to the preverified directory
+          JavaME::Tools.preverify(compiled_dir, preverified_dir) do |j|
+            j.cldc_version = @cldc_version
+            j.classpath = cp + @bootclasspath
+          end
+          
+          # package up verified classes
+          package_files.add("#{preverified_dir}/*")
+        end
+        
+        # package up resources
+        package_files.add(*@resources) unless @resources.empty?
+        package_files.each do |f|
+          p = Pathname.new(f)
+          
+          if p.extname == ".jar"
+            Java::Tools::Jar.extract(f, package_dir)
+          else
+            cp_r_if(f, package_dir) { |p| !(p =~ /\.svn$/) }
+          end
+        end
+        
+        # remove svn files we may have copied
+        exclude_files = FileList.new
+        exclude_files.clear_exclude
+        exclude_files.add("#{package_dir}/META-INF")
+        exclude_files.add("#{package_dir}/**/.svn")
+        
+        exclude_files.each do |file|
+          rm_rf(file)
+        end
+        
+        Java::Tools::Jar.new(jar_path, FileList.new(package_dir)) do |jar|
+          jar.manifest = @manifest
+        end
+      end
+      
+      target.output :tag => [:default, :jar], 
+                    :output => jar_path,
+                    :deployable => true
+                    
+      target.output :tag => :jad_config, 
+                    :output => @jad_config,
+                    :deployable => false
+      
+      @tasks << jar_task
+      
+      return jar_task
+    end
+  end
+end