jrubyfx-fxmlloader 0.2-java → 0.3-java

data/lib/fxmlloader/value_elts.rb

@@ -43,8 +43,6 @@ class StupidFixTODOInsets < Java::javafx::geometry::InsetsBuilder
   end
 
   def size
-    dputs "GAAAAAAAAAAAAAA!!!!!"
-    dputs caller
     990
   end
   def to_s
@@ -71,44 +69,35 @@ class ValueElement < Element
   end
 
   def processEndElement()
-    dputs callz + "process end super?"
     super
-    dputs callz + "process end superd!"
-    dp value
 
     # Build the value, if necessary
     if (value.is_a? Builder)
-      dputs "build it"
       updateValue(value.build());
-dputs "process it"
       processValue();
     else
       processInstancePropertyAttributes();
     end
-dputs "donet"
     processEventHandlerAttributes();
-dputs "ahndersAtrrs"
     # Process static property attributes
     if (staticPropertyAttributes.length > 0)
       for attribute in staticPropertyAttributes
-        dputs "process prodp attr-----------"
-        dp attribute
         processPropertyAttribute(attribute);
       end
     end
-dputs "staticpro"
     # Process static property elements
     if (staticPropertyElements.length > 0)
       for  element in staticPropertyElements
         RubyWrapperBeanAdapter.put(value, element.sourceType, element.name, element.value);
       end
     end
-dputs "parentS>AS"
+
+    rnest -1
+    rputs value, ((rfx_id(value) && rfx_id_set?(value)) || rno_show?(value) ? ""  : "end")
     if (parent != nil)
       if (parent.isCollection())
         parent.add(value);
       else
-        dputs callz + " ANd setting  #{value} on #{parent}"
         parent.set value
       end
     end
@@ -150,8 +139,13 @@ dputs "parentS>AS"
       # checking the version JavaFX API - print warning if not supported
       defaultNSURI = xmlStreamReader.getNamespaceContext().getNamespaceURI("");
       if (defaultNSURI != nil)
-        nsVersion = defaultNSURI[(defaultNSURI.lastIndexOf("/") + 1)..-1]
-        if (parentLoader.compareJFXVersions(FXL::JAVAFX_VERSION, nsVersion) < 0)
+        nsVersion = defaultNSURI[(defaultNSURI.rindex("/") + 1)..-1]
+        jfx_version = if defined? FXL::JAVAFX_VERSION
+          FXL::JAVAFX_VERSION
+        else
+          "http://javafx.com/javafx/2.2"
+        end
+        if (parentLoader.compareJFXVersions(jfx_version, nsVersion) < 0)
           Logging.getJavaFXLogger().warning("Loading FXML document with JavaFX API of version " + nsVersion + " by JavaFX runtime of version " + FXL::JAVAFX_VERSION);
         end
       end
@@ -169,16 +163,15 @@ dputs "parentS>AS"
         # set fx:id property value to Node.id only if Node.id was not
         # already set when processing start element attributes
         if (properties[idProperty.value] == nil)
-          dputs callz + "saving ID property #{idProperty.value}"
           properties[idProperty.value()]= @fx_id;
         end
       end
-      dputs callz+ "About to set instance variable #{@fx_id}"
+      rputs value, "__local_fx_id_setter.call(#{@fx_id.inspect}, self)"
+      rfx_id value, @fx_id
       # Set the controller field value
       if (parentLoader.controller != nil)
         field = parentLoader.controller.instance_variable_set("@" + @fx_id, value)
       end
-      dputs callz + "Set.."
     end
   end
 
@@ -221,7 +214,6 @@ dputs "parentS>AS"
 #            raise LoadException.new("Invalid identifier.");
 #          end
 #        end
-dputs callz + "Found FXID is #{value}"
         @fx_id = value;
 
       elsif (localName == (FXL::FX_CONTROLLER_ATTRIBUTE))
@@ -229,7 +221,6 @@ dputs callz + "Found FXID is #{value}"
           raise LoadException.new(FXL::FX_NAMESPACE_PREFIX + ":" + FXL::FX_CONTROLLER_ATTRIBUTE		+ " can only be applied to root element.");
         end
 
-dputs callz + "Found controller attrib is #{value} (#{parentLoader.controller}, #{staticLoad})"
         if (parentLoader.controller != nil)
           raise LoadException.new("Controller value already specified.");
         end
@@ -237,7 +228,7 @@ dputs callz + "Found controller attrib is #{value} (#{parentLoader.controller},
         if (!staticLoad)
           type = nil
           begin
-            type = parentLoader.constantize(value)
+            type = value.constantize_by
           rescue ClassNotFoundException => exception
             raise LoadException.new(exception);
           end
@@ -259,7 +250,6 @@ dputs callz + "Found controller attrib is #{value} (#{parentLoader.controller},
         raise LoadException.new("Invalid attribute.");
       end
     else
-      dputs callz + "Super Again!"
       super(prefix, localName, value);
     end
   end

data/lib/jrubyfx-fxmlloader.rb

@@ -33,11 +33,6 @@ rescue  LoadError, NameError
   exit -2
 end
 
-#java_import 'javax.xml.stream.util.StreamReaderDelegate'
-#java_import 'javax.xml.stream.XMLStreamException', 'javax.xml.stream.XMLInputFactory',
-#  'java.io.InputStreamReader', 'javax.xml.stream.XMLStreamConstants'
-java_import 'java.net.URL', 'java.nio.charset.Charset', 'java.lang.ClassNotFoundException'
-#java_import 'javafx.fxml.LoadException'
 java_import 'javafx.fxml.JavaFXBuilderFactory'
 java_import 'java.lang.InstantiationException', 'java.lang.IllegalAccessException'
 
@@ -45,23 +40,15 @@ java_import *%w[com.sun.javafx.Logging
 java.io.IOException
 java.io.InputStream
 java.io.InputStreamReader
-java.lang.reflect.Constructor
+java.lang.ClassNotFoundException
 java.lang.reflect.InvocationTargetException
 java.lang.reflect.Modifier
 java.lang.reflect.ParameterizedType
-java.lang.reflect.Type
 java.net.URL
 java.nio.charset.Charset
 java.util.AbstractMap
-java.util.ArrayList
-java.util.Collections
-java.util.HashMap
-java.util.LinkedList
 java.util.List
-java.util.Map
 java.util.ResourceBundle
-java.util.Set
-java.util.regex.Pattern
 
 javafx.beans.DefaultProperty
 javafx.beans.property.Property
@@ -122,6 +109,149 @@ end
 def dprint(*args)
   print *args if $DEBUG_IT_FXML
 end
+# TODO: clean this up
+$RB_PREFIX = ""
+def rnest(num)
+  if num > 0
+    $RB_PREFIX += " "
+  else
+    $RB_PREFIX = $RB_PREFIX[0...-1]
+  end
+end
+$RB_MAPPER = {}
+$RB_CMAPPER = {}
+$RB_IDMAPPER = {}
+$RB_NShowMAPPER = {}
+$last_elt = nil
+
+def rno_show(elt)
+  $RB_NShowMAPPER[elt]=true
+end
+def rno_show?(elt)
+  !!$RB_NShowMAPPER[elt]
+end
+
+def rmap_wrap(elt)
+  if elt.kind_of? Java::ComSunJavafxCollections::ObservableListWrapper
+    SecretHashCompararator.new(elt)
+  else
+    elt
+  end
+end
+def rputs(elt, args)
+  if $DEBUG_IT_FXML_RB
+    if elt == nil
+      elt = $last_elt
+    else
+      $last_elt = elt = rmap_wrap(elt)
+    end
+    unless $RB_MAPPER[elt]
+      $RB_MAPPER[elt] = ""
+    end
+    $RB_MAPPER[elt] << $RB_PREFIX
+    $RB_MAPPER[elt] << args
+    $RB_MAPPER[elt] << "\n"
+  end
+end
+
+def rfx_id(elt, val=nil)
+  elt = rmap_wrap elt
+  if val
+    $RB_IDMAPPER[elt] = val
+  else
+    $RB_IDMAPPER[elt]
+  end
+end
+def rfx_id_set?(elt)
+  elt = rmap_wrap elt
+  !$RB_MAPPER[elt] or $RB_MAPPER[elt].include? "instance_variable_get(#{("@" + rfx_id(elt)).to_sym.inspect})"
+end
+def rmorph(old, new)
+  elt = rmap_wrap elt
+  $RB_MAPPER[new] = "build(FxmlBuilderBuilder, #{($RB_CMAPPER[old]||{}).inspect}, #{old.wrapped_class.ruby_class.inspect}) do\n"
+end
+
+def rctor(elt, k, v)
+  if $DEBUG_IT_FXML_RB
+    elt = rmap_wrap elt
+    $RB_CMAPPER[elt] = {} unless $RB_CMAPPER[elt]
+    $RB_CMAPPER[elt][k] = v
+  end
+end
+def rget(elt, action=:nuke_from_standard_orbit_captain)
+  elt = rmap_wrap elt
+  tmp = $RB_MAPPER[elt]
+  tmp.strip! if tmp
+  $RB_MAPPER[elt] = rfx_id(elt) ? "__local_fxml_controller.instance_variable_get(#{("@" + rfx_id(elt)).to_sym.inspect})" : nil
+
+  tmp
+end
+$RB_SCRIPT_ENGINE_MAPPINGS = {}
+def rputs_script(sem, lang)
+  $RB_SCRIPT_ENGINE_MAPPINGS[sem] = lang
+end
+
+def rget_sem(sem)
+  $RB_SCRIPT_ENGINE_MAPPINGS[sem]
+end
+
+def rsem_out
+  if $RB_SCRIPT_ENGINE_MAPPINGS != {}
+    ["(__local_sem_inst = Java.javax.script.ScriptEngineManager.new).setBindings(javax.script.SimpleBindings.new(__local_namespace))",
+      *$RB_SCRIPT_ENGINE_MAPPINGS.map{|sem, lang|
+        "(__local_sem_lang_inst_#{lang} = __local_sem_inst.getEngineByName(#{lang.inspect}))" +
+          ".setBindings(__local_sem_inst.getBindings(), javax.script.ScriptContext.ENGINE_SCOPE)"
+      }
+    ].join("\n")
+  end
+end
+
+class SecretHashCompararator
+  attr_accessor :obj
+  def initialize(obj)
+    @obj = obj
+  end
+  def hash
+    @obj.object_id
+  end
+  def eql?(rhs)
+    self == rhs
+  end
+  def ==(rhs)
+    @obj.object_id == rhs.object_id or (rhs.is_a? SecretHashCompararator and @obj.object_id == rhs.hash)
+  end
+end
+
+class FxmlBuilderBuilder # the builder builder (builds builders)
+  @@bf = Java::javafx.fxml.JavaFXBuilderFactory.new
+  def self.new(arg_map, builder_type)
+    builder = @@bf.getBuilder(builder_type)
+    arg_map.each do |k, v|
+      builder.put(k, v) # DON't use []= or we have to wrap it
+    end
+    builder.build
+  end
+end
+
+class FactoryBuilderBuilder # builder to build factories
+  def self.new(type, factory)
+    type = type.java_class
+    factoryMethod = nil
+    begin
+      factoryMethod = MethodUtil.getMethod(type, factory, []);
+    rescue NoSuchMethodException => exception
+      raise LoadException.new(exception);
+    end
+
+    begin
+      return MethodUtil.invoke(factoryMethod, nil, []);
+    rescue IllegalAccessException => exception
+      raise LoadException.new(exception);
+    rescue InvocationTargetException => exception
+      raise LoadException.new(exception);
+    end
+  end
+end
 
 # Override to safely get ruby class of non-java_class objects
 class Class
@@ -130,26 +260,17 @@ class Class
   end
 end
 
-#Long to avoid collisions
-MAGIC_FXML_JAVAFX_JRUBYFX_FXMLLOADER__FILE__LOCATION_SUPER_SECRET = __FILE__
-
 FXL = java_import('javafx.fxml.FXMLLoader')[0]
 class FxmlLoader
-  attr_accessor :location, :root, :template, :builderFactory, :namespace, :staticLoad, :current, :controllerFactory
+  attr_accessor :location, :root, :template, :builderFactory, :namespace, :staticLoad, :current, :controllerFactory, :charset
+  attr_accessor :scriptEngine
   attr_reader :controller
   FX_NAMESPACE_VERSION="1"
+  @@fxml_jit_info = {}
   def initialize(url=nil, ctrlr=nil, resourcs=nil, buildFactory=nil, charset=nil, loaders=nil)
     @location = url
     @builderFactory = buildFactory || JavaFXBuilderFactory.new
     @template = false
-    if resourcs
-      dputs "WHOA WHOAT!!!! resources"
-      dp resourcs
-    end
-    if loaders
-      dputs "WHOA WHOAT!!!! loaders"
-      dp loaders
-    end
     @namespace = FXCollections.observableHashMap()
     self.controller = ctrlr
     @packages = []
@@ -167,9 +288,15 @@ class FxmlLoader
     end
   end
 
-  def load()
-    dp "This is the namespace", @namespace
+  # either :no_jit, or a number above 0 representing the number of times before jitting a fxml file
+  def load(jruby_exts = {jruby_ext: {}})
+    @jruby_ext = {jit: 0}.merge(jruby_exts[:jruby_ext])
     # TODO: actually open it properly
+    unless jit_info = @@fxml_jit_info[file_path = @location.to_s]
+      validate = true
+      validate = @jruby_ext[:jit_validate] if @jruby_ext.has_key? :jit_validate
+      jit_info = @@fxml_jit_info[file_path] = FxmlJitInfo.new(file_path, @jruby_ext[:jit], @jruby_ext[:jit_save_to], @jruby_ext[:jit_cache], validate, @jruby_ext[:jit_opts])
+    end
     inputStream = @location.open_stream
     if @template
       @root = nil
@@ -182,6 +309,22 @@ class FxmlLoader
 
     @script_engine = nil
 
+    $DEBUG_IT_FXML_RB = jit_info.should_jit?
+    # if we have it cached, use the jitted method
+    if jit_info.compiled?
+      begin
+        return :dont_load if @jruby_ext[:dont_load]
+        return jit_info.__build_via_jit(@controller, @namespace, @jruby_ext)
+      rescue Exception, java.lang.Throwable
+        puts "JIT compiled method for #{@location.to_s} FAILED with error:"
+        puts $!
+        puts $!.backtrace
+        puts "Reverting to normal parsing..."
+        jit_info.jit_settings = :no_jit
+        jit_info.decompile
+      end
+    end
+
     begin
       xmlInputFactory = XMLInputFactory.newFactory
       xmlInputFactory.setProperty("javax.xml.stream.isCoalescing", true)
@@ -197,38 +340,40 @@ class FxmlLoader
     # Parse the XML stream
 		begin
 			while @xmlStreamReader.hasNext()
-        dputs "......"
         event = @xmlStreamReader.next();
-        dputs "#{event} aout happened, dude"
 				case event
         when XMLStreamConstants::PROCESSING_INSTRUCTION
-          dputs "processing instr"
           processProcessingInstruction
         when XMLStreamConstants::COMMENT
-          dputs "processing comment"
           processComment
         when XMLStreamConstants::START_ELEMENT
-          dputs "processing start"
           processStartElement
         when XMLStreamConstants::END_ELEMENT
-          dputs "processing end"
           processEndElement
         when XMLStreamConstants::CHARACTERS
-          dputs "processing chars"
           processCharacters
         end
       end
 		rescue XMLStreamException => exception
 			raise Exception.new(exception)
     end
-    dputs "Saving stuff!!!!s"
     if @controller
       # TODO: initialize should be called here
       # Inject controller fields
       @controller.instance_variable_set("@" + FXL::LOCATION_KEY, @location)
       @controller.instance_variable_set("@" + FXL::RESOURCES_KEY, @resources)
     end
-
+    if $DEBUG_IT_FXML_RB
+      code = "#{rsem_out}\n#{rget @root}"
+      jit_info.compile(code)
+    end
+    $RB_CMAPPER = {}
+    $RB_IDMAPPER = {}
+    $RB_MAPPER = {}
+    $RB_PREFIX = ""
+    $RB_NShowMAPPER = {}
+    $last_elt = nil
+    $RB_SCRIPT_ENGINE_MAPPINGS = {}
 
     @xmlStreamReader = nil
     return @root
@@ -261,8 +406,9 @@ class FxmlLoader
 
 		unless staticLoad
 			scriptEngineManager = getScriptEngineManager()
-			scriptEngine = scriptEngineManager.getEngineByName(language)
-			scriptEngine.setBindings(scriptEngineManager.getBindings(), ScriptContext.ENGINE_SCOPE)
+			@scriptEngine = scriptEngineManager.getEngineByName(language)
+      rputs_script @scriptEngine, language
+			@scriptEngine.setBindings(scriptEngineManager.getBindings(), ScriptContext.ENGINE_SCOPE)
     end
   end
 
@@ -294,6 +440,8 @@ class FxmlLoader
 		# Set the root value
 		unless @root
 			@root = @current.value;
+      rputs @root, "__local_jruby_ext[:on_root_set].call(self) if __local_jruby_ext[:on_root_set]"
+      @jruby_ext[:on_root_set].call(@root) if @jruby_ext[:on_root_set]
     end
   end
 
@@ -348,11 +496,6 @@ class FxmlLoader
           pppn = pppn.parent
         end
         prefixz = (" " * numz) + prefixz
-        dputs "#{prefixz}Creating new stuff"
-        dprint prefixz
-        dp localName
-        dprint prefixz
-        dp type
 
 				if type
 					if @loadListener
@@ -415,7 +558,6 @@ class FxmlLoader
   end
 
   def processEndElement()
-    dputs "ending!!!!!!!!"
 		@current.processEndElement();
 		if @loadListener
 			@loadListener.endElement(@current.value);
@@ -443,82 +585,6 @@ class FxmlLoader
 			raise LoadException.new(exception);
 		end
 	end
-  
-  # steal handy methods from activesupport
-  # Tries to find a constant with the name specified in the argument string.
-  #
-  # 'Module'.constantize # => Module
-  # 'Test::Unit'.constantize # => Test::Unit
-  #
-  # The name is assumed to be the one of a top-level constant, no matter
-  # whether it starts with "::" or not. No lexical context is taken into
-  # account:
-  #
-  # C = 'outside'
-  # module M
-  # C = 'inside'
-  # C # => 'inside'
-  # 'C'.constantize # => 'outside', same as ::C
-  # end
-  #
-  # NameError is raised when the name is not in CamelCase or the constant is
-  # unknown.
-  def constantize(camel_cased_word)
-    names = camel_cased_word.split('.')
-    names.shift if names.empty? || names.first.empty?
-
-    names.inject(Object) do |constant, name|
-      if constant == Object
-        constant.const_get(name)
-      else
-        candidate = constant.const_get(name)
-        next candidate if constant.const_defined?(name, false)
-        next candidate unless Object.const_defined?(name)
-
-        # Go down the ancestors to check it it's owned
-        # directly before we reach Object or the end of ancestors.
-        constant = constant.ancestors.inject do |const, ancestor|
-          break const if ancestor == Object
-          break ancestor if ancestor.const_defined?(name, false)
-          const
-        end
-
-        # owner is in Object, so raise
-        constant.const_get(name, false)
-      end
-    end
-  end
-
-  # Tries to find a constant with the name specified in the argument string.
-  #
-  # 'Module'.safe_constantize # => Module
-  # 'Test::Unit'.safe_constantize # => Test::Unit
-  #
-  # The name is assumed to be the one of a top-level constant, no matter
-  # whether it starts with "::" or not. No lexical context is taken into
-  # account:
-  #
-  # C = 'outside'
-  # module M
-  # C = 'inside'
-  # C # => 'inside'
-  # 'C'.safe_constantize # => 'outside', same as ::C
-  # end
-  #
-  # +nil+ is returned when the name is not in CamelCase or the constant (or
-  # part of it) is unknown.
-  #
-  # 'blargle'.safe_constantize # => nil
-  # 'UnknownModule'.safe_constantize # => nil
-  # 'UnknownModule::Foo::Bar'.safe_constantize # => nil
-  def safe_constantize(camel_cased_word)
-    constantize(camel_cased_word)
-  rescue NameError => e
-    raise unless e.message =~ /(uninitialized constant|wrong constant name) #{const_regexp(camel_cased_word)}$/ ||
-      e.name.to_s == camel_cased_word.to_s
-  rescue ArgumentError => e
-    raise unless e.message =~ /not missing constant #{const_regexp(camel_cased_word)}\!$/
-  end
 
 	def getType(name)
 		type = nil
@@ -548,8 +614,8 @@ class FxmlLoader
           # check for ruby
           # TODO: this should require an import or something perhaps? need to think more about this?
           begin
-						type = constantize(name)
-					rescue 
+						type = name.constantize_by(".")
+					rescue
 						# No-op
 					end
         end
@@ -675,6 +741,55 @@ class FxmlLoader
   end
 end
 
+class String
+
+  # steal handy methods from activesupport
+  # Tries to find a constant with the name specified in the argument string.
+  #
+  # 'Module'.constantize # => Module
+  # 'Test::Unit'.constantize # => Test::Unit
+  #
+  # The name is assumed to be the one of a top-level constant, no matter
+  # whether it starts with "::" or not. No lexical context is taken into
+  # account:
+  #
+  # C = 'outside'
+  # module M
+  # C = 'inside'
+  # C # => 'inside'
+  # 'C'.constantize # => 'outside', same as ::C
+  # end
+  #
+  # NameError is raised when the name is not in CamelCase or the constant is
+  # unknown.
+  def constantize_by(splitter="::")
+    camel_cased_word = self
+    names = camel_cased_word.split(splitter)
+    names.shift if names.empty? || names.first.empty?
+
+    names.inject(Object) do |constant, name|
+      if constant == Object
+        constant.const_get(name)
+      else
+        candidate = constant.const_get(name)
+        next candidate if constant.const_defined?(name, false)
+        next candidate unless Object.const_defined?(name)
+
+        # Go down the ancestors to check it it's owned
+        # directly before we reach Object or the end of ancestors.
+        constant = constant.ancestors.inject do |const, ancestor|
+          break const if ancestor == Object
+          break ancestor if ancestor.const_defined?(name, false)
+          const
+        end
+
+        # owner is in Object, so raise
+        constant.const_get(name, false)
+      end
+    end
+  end
+end
+
 
 class SRDelegateClass < StreamReaderDelegate
   def getPrefix()
@@ -703,6 +818,7 @@ require_relative 'fxmlloader/value_elts'
 require_relative 'fxmlloader/real_elts'
 require_relative 'fxmlloader/rrba'
 require_relative 'fxmlloader/rorba'
+require_relative 'fxmlloader/fxml_jit_info'
 require_relative 'FXMLLoader-j8.jar'
 
 java_import 'org.jruby.jfx8.KeyPath'
@@ -721,4 +837,4 @@ class RRBAdapters < org.jruby.jfx8.RubyBeanAdapter
   end
 end
 
-org.jruby.jfx8.RubyBeanAdapter.load_ruby_space RRBAdapters.new
+org.jruby.jfx8.RubyBeanAdapter.load_ruby_space RRBAdapters.new