filament 0.2.3 → 0.3.0

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

@@ -1,181 +0,0 @@
-require 'filament/java/mixins/java_mixin'
-
-module Filament::JavaME::Mixins
-  module LibraryMixin
-    include Java::Mixins::JavaMixin
-    
-    attr_accessor2 :obfuscate
-    
-    attr_writer :package_deps
-    attr_reader :srcs, :resources, :manifest, :platform, :cldc_version
-    
-    def init_library
-      init_java
-      @srcs = FileList2.new
-      @resources = FileList2.new
-      @manifest = nil
-      @package_deps = false
-      @obfuscate = 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 jar_path
-      return "#{output_dir}/#{@name}.jar"
-    end
-    
-    def define_library(target)
-      compiled_dir = directory(:compiled)
-      obfuscated_dir = directory(:obfuscated)
-      preverified_dir = directory(:preverified)
-      package_dir = directory(:package)
-      proguard_dir = directory(:proguard)
-      proguard_preverified_dir = directory(:proguard_preverified)
-      
-      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.each do |file|
-          rm_rf(file)
-        end
-        
-        # obfuscate, if necessary
-        if @obfuscate
-          Java::Tools::proguard(package_dir, proguard_dir) do |o|
-            (@classpath + @bootclasspath).each do |libraryjar|
-              o.libraryjars libraryjar
-            end
-            
-            target.flattened_deps.each do |dep|
-              b = dep[:proguard]
-              b.call(o) unless b.nil?
-            end
-            
-            o.defaultpackage "''"
-            o.dontusemixedcaseclassnames
-            o.allowaccessmodification
-            o.keep 'public class * extends javax.microedition.midlet.MIDlet'
-          end
-          
-          FileList.new("#{proguard_dir}/*").each do |f|
-            cp_r_if(f, proguard_preverified_dir) { |p| !(p =~ /\.class$/) }
-          end
-          
-          JavaME::Tools::preverify(proguard_dir, proguard_preverified_dir) do |j|
-            j.cldc_version = @cldc_version
-            j.classpath = cp + @bootclasspath
-          end
-
-          Java::Tools::Jar.new(jar_path, FileList.new(proguard_preverified_dir)) do |jar|
-            jar.manifest = @manifest
-          end
-        else
-          Java::Tools::Jar.new(jar_path, FileList.new(package_dir)) do |jar|
-            jar.manifest = @manifest
-          end
-        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

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

@@ -1,114 +0,0 @@
-require 'filament/javame/mixins/library_mixin'
-
-module Filament::JavaME::Mixins
-  module SuiteMixin
-    include JavaME::Mixins::LibraryMixin
-    
-    attr_accessor2 :defaultmidlet_class, 
-                   :suite_version, :suite_name, :suite_icon, :suite_vendor,
-                   :me_configuration, :me_profile
-    
-    # adds a midlet hash with keys :icon, :classname, and :name
-    def add_midlet(midlet)
-      if midlet == :default
-        midlet = { :classname => defaultmidlet_class,
-                   :icon => suite_icon,
-                   :name => suite_name }
-      end
-      
-      @midlets << midlet
-    end
-    
-    def init_suite
-      init_library
-      @descriptor_config = Proc.new {}
-      @package_deps = true
-      @obfuscate = false # TODO should be based on $build_type 
-      @defaultmidlet_class = nil
-      @midlets = []
-      
-      @me_configuration = 'CLDC-1.0'
-      @me_profile = 'MIDP-2.0'
-    end
-    
-    def jad_path
-      jad_name = Pathname.new(jar_path).basename(".*").to_s + '.jad'
-      return "#{output_dir}/#{jad_name}"
-    end
-
-    def manifest_path
-      return "#{working_dir}/MANIFEST.MF"
-    end
-        
-    def descriptor_config(&block)
-      @descriptor_config = block
-    end
-    
-    def define_jad(target)
-    	  # create a list for imported jad configs
-    	  configs = []
-    	  
-    	  # start with this target
-    	  config = target[:jad_config] 
-    	  configs << config unless config.nil?
-    	  
-    	  target.flattened_deps.each do |dep|
-    	    # ask each dep for its contribution
-        	config = dep[:jad_config]
-        	configs << config unless config.nil?
-    	  end
-    	  
-    	  full_config = Proc.new do |d|
-    	    d.suite_version = @suite_version
-    	    d.suite_name = @suite_name
-    	    d.suite_icon = @suite_icon
-    	    d.suite_vendor = @suite_vendor
-    	    d.me_configuration = @me_configuration
-    	    d.me_profile = @me_profile
-
-    	    @midlets.each do |midlet|
-    	      d.add_midlet(midlet)
-    	    end
-    	    
-    	    @descriptor_config.call(d)
-    	    
-    	    configs.each do |config|
-    	      config.call(d)
-    	    end
-    	  end
-
-      jad_task = file jad_path => jar_path do |t|
-        JavaME::Tools::write_manifest(manifest_path, &full_config)
-        Java::Tools::Jar.new(jar_path) do |jar|
-          jar.update = true
-          jar.manifest = manifest_path
-        end
-        JavaME::Tools::write_jad(jad_path, jar_path, &full_config)
-      end
-
-      target.output :tag => :jad,
-                    :output => jad_path,
-                    :deployable => true
-
-      @tasks << jad_task
-      return jad_task
-    end
-    
-    def define_suite(target)
-      # define all the tasks
-      # and add extra dependencies
-
-      jad_task = define_jad(target)
-      library_task = define_library(target)
-
-      target.output(:tag => :execute,
-                    :output => Proc.new do; emulate; end)
-
-      return jad_task, library_task
-    end
-    
-    def emulate(midletclass=@defaultmidlet_class)
-      JavaME::Tools::emulate(jad_path, midletclass)
-    end
-  end
-end