jrubyfx-fxmlloader 0.2-java → 0.3-java

data/README

@@ -1,5 +1,17 @@
-== FXMLLoader
+# JRubyFX-FxmlLoader
 
-Use with JRubyFX.
+JRubyFX-FxmlLoader is the JIT-enabled FXML parser for the JRubyFX project based
+on the official OpenJDK 8 FXML parser. FxmlLoader strives to be a nearly drop-in
+replacement FxmlLoader, only differing in JRuby compatibility.
 
-rake gem to build
+At this point,
+most code is directly copied from OpenJDK and converted to ruby via regexes and
+as such is far from idiomatic ruby. The JIT compiler is also a work in progress.
+
+If you would like to help clean up the code please do but be careful about breaking
+FXML. Any 100% standard Java FXML document should work *identically* when run as a JRuby FXML document and
+vice-versa with the exception of JRuby support (like ruby classes & controllers).
+
+Use with JRubyFX!
+
+rake gem to build. Note that half of this project is java and must be compiled.

data/Rakefile

@@ -45,7 +45,7 @@ task :gem => :jar
 
 spec = Gem::Specification.new do |s|
   s.name = 'jrubyfx-fxmlloader'
-  s.version = '0.2'
+  s.version = '0.3'
   s.platform    = 'java'
   s.has_rdoc = true
   s.extra_rdoc_files = ['README', 'LICENSE']

data/lib/fxmlloader/elts.rb

@@ -49,16 +49,19 @@ class Element
         collection = false;
       end
     end
-    dputs callz + "Is it a collection? #{collection.inspect} <= #{@value.java_class}"
     return collection;
   end
 
-  def add(element)
-    dputs callz + "about to add #{element} to #{value.to_java}"
+  def add(element, prop_name=nil, rputs_elt=nil)
     # If value is a list, add element to it; otherwise, get the value
     # of the default property, which is assumed to be a list and add
     # to that (coerce to the appropriate type)
     if (@value.kind_of?(Enumerable) || @value.java_kind_of?(java.util.List))
+      if prop_name == nil
+        rputs value, "add(#{rget(element)||element.inspect})"
+      else
+        rputs @parent.value, "get#{prop_name[0].upcase}#{prop_name[1..-1]}.add(#{rputs_elt || rget(element)||element.inspect})"
+      end
       value.to_java
     else
       type = value.java_class
@@ -69,10 +72,11 @@ class Element
       list =  getProperties[defaultPropertyName]
 
       # Coerce the element to the list item type
-      if (!Map.java_class.assignable_from?(type))
+      if (!java.util.Map.java_class.assignable_from?(type))
         listType = @valueAdapter.getGenericType(defaultPropertyName);
         element = RubyWrapperBeanAdapter.coerce(element, RubyWrapperBeanAdapter.getListItemType(listType));
       end
+      rputs @value, "get#{defaultPropertyName[0].upcase}#{defaultPropertyName[1..-1]}.add(#{rget(element)||element.inspect})"
       list = list.to_java if list.class == Java::JavaObject
       list
     end.add(element)
@@ -94,38 +98,17 @@ class Element
   end
 
   def updateValue(value)
-    dputs callz + "Updating value from #{@value} to #{value.class}"
     @value = value;
     @valueAdapter = nil;
   end
 
   def isTyped()
-    dputs callz + "checking if typed"
-    dp @value.class
-    dp @value
-    q =  !(@value.java_kind_of? Java::java.util.Map or @value.is_a? Hash  );
-    dputs callz + "type result: #{q.inspect}"
-    q
+    !(@value.java_kind_of? Java::java.util.Map or @value.is_a? Hash  )
   end
 
   def getValueAdapter()
     if (@valueAdapter == nil)
-      dputs callz + "trying to get itqq"
-      dprint callz
-      dprint @value
-      dputs @value.class
-      dputs caller
-      if @value.class.to_s == "Java::JavafxFxml::ObjectBuilder"
-        dputs caller
-      end
-      if @value.is_a? java.lang.Object
-        dputs callz + "trying to call wrapper"
-      @valueAdapter = RubyWrapperBeanAdapter.new(@value);
-      else
-        dputs callz + "trying to call ruby object wrapper"
-        @valueAdapter = RubyObjectWrapperBeanAdapter.new(@value)
-      end
-      dputs callz + "got"
+      @valueAdapter = RubyWrapperBeanAdapter.for(@value)
     end
     return @valueAdapter;
   end
@@ -172,7 +155,6 @@ class Element
         if (@loadListener != nil)
           @loadListener.readEventHandlerAttribute(localName, value);
         end
-        dputs callz + "found eventHandler prefix #{prefix}, #{localName}, #{value}"
         eventHandlerAttributes <<(Attribute.new(localName, nil, value));
       else
         i = localName.rindex('.');
@@ -183,15 +165,12 @@ class Element
             @loadListener.readPropertyAttribute(localName, nil, value);
           end
 
-        dputs callz + "found property attrib #{prefix}, #{localName}, #{value}"
           instancePropertyAttributes << (Attribute.new(localName, nil, value));
         else
           # The attribute represents a static property
           name = localName[(i + 1)..-1];
           sourceType = parentLoader.getType(localName[0, i]);
 
-        dputs callz + "found static property #{prefix}, #{localName}, #{value}"
-        dputs callz + "and its #{sourceType}, #{staticLoad}"
           if (sourceType != nil)
             if (@loadListener != nil)
               @loadListener.readPropertyAttribute(name, sourceType, value);
@@ -217,7 +196,6 @@ class Element
   def processPropertyAttribute(attribute)
     value = attribute.value;
     if (isBindingExpression(value))
-      dputs callz  + "is a binding !"
       # Resolve the expression
 
       if (attribute.sourceType != nil)
@@ -235,38 +213,28 @@ class Element
       end
 
       value = value[2..-2]    # TODO: BINDING_EXPRESSION_PREFIX == ${
-        #value.length() - 1];
+      #value.length() - 1];
       # TODO: this only works for 7, not 8
-      dputs "getting expression value of '#{value}' with #{parentLoader.namespace}"
       expression = Expression.valueOf(value);
-      dputs callz + "got the expression as '#{expression}'"
-      dp expression
       # Create the binding
       targetAdapter = RubyWrapperBeanAdapter.new(@value);
-      dputs callz + "target adapter is #{targetAdapter} from #{value}"
       propertyModel = targetAdapter.getPropertyModel(attribute.name).to_java
       type = targetAdapter.getType(attribute.name);
-      dputs callz + "prop model is #{propertyModel.inspect} and type is #{type.inspect}"
       if (propertyModel.is_a? Property)
-        dputs callz + "checking out value using #{parentLoader.namespace}"
+        rputs @value, "#{attribute.name}Property.bind(RRExpressionValue.new(__local_namespace, Java::org.jruby.jfx8.Expression.valueOf(#{value.inspect}), Java::#{type.name.gsub(/[\$\.]/, "::")}.java_class))"
         #expression.value_property.addListener(JRExpressionTargetMapping.new(expression, getProperties(), Expression.split(value)));
         ( propertyModel).bind(RRExpressionValue.new(parentLoader.namespace, expression, type));
-        dputs callz + "bound!"
       end
     elsif (isBidirectionalBindingExpression(value))
       raise UnsupportedOperationException.new("This feature is not currently enabled.");
     else
-      dputs callz + "processing 3 for #{attribute.sourceType}, #{attribute.name}, #{value}"
       processValue3(attribute.sourceType, attribute.name, value);
     end
   end
 
   def isBindingExpression(aValue)
-    dputs callz + "checking if '#{aValue}' is a binding prefix..."
     # TODO: BINDING_EXPRESSION_PREFIX == ${
-    q =  aValue.start_with?("${") && aValue.end_with?(FXL::BINDING_EXPRESSION_SUFFIX);
-    dputs callz + "it is? #{q.inspect}"
-    q
+    aValue.start_with?("${") && aValue.end_with?(FXL::BINDING_EXPRESSION_SUFFIX);
   end
 
   def isBidirectionalBindingExpression(aValue)
@@ -279,7 +247,6 @@ class Element
     processed = false;
     #process list or array first
     if (sourceType == nil && isTyped())
-      dputs callz + "getting value adptr"
       lvalueAdapter = getValueAdapter();
       type = lvalueAdapter.getType(propertyName);
 
@@ -288,9 +255,8 @@ class Element
         dp sourceType, propertyName, aValue
         dp lvalueAdapter
         dp caller
-        raise PropertyNotFoundException.new("Property \"" + propertyName          + "\" does not exist" + " or is read-only.");
+        raise("Property \"" + propertyName          + "\" does not exist" + " or is read-only.");
       end
-      dputs "checking assignable"
       if (List.java_class.assignable_from?(type) && lvalueAdapter.read_only?(propertyName))
         populateListFromString(lvalueAdapter, propertyName, aValue);
         processed = true;
@@ -299,11 +265,8 @@ class Element
         processed = true;
       end
     end
-    dputs callz + "276"
     if (!processed)
-      dputs callz + "Must appky it"
       applyProperty(propertyName, sourceType, resolvePrefixedValue(aValue));
-      dputs callz + "280"
       processed = true;
     end
     return processed;
@@ -336,7 +299,11 @@ class Element
         return aValue;
       else
         begin
-          return (aValue[0] == '/') ? classLoader.getResource(aValue[1..-1]).to_s : URL.new(parentLoader.location, aValue).to_s
+          if $JRUBYFX_AOT_COMPILING
+            return RelativeFXMLString.new(aValue, URL.new(parentLoader.location, aValue).to_s)
+          else
+            return (aValue[0] == '/') ? classLoader.getResource(aValue[1..-1]).to_s : URL.new(parentLoader.location, aValue).to_s
+          end
         rescue MalformedURLException => e
           dp e
           dputs "#{parentLoader.location} + /+ #{aValue}"
@@ -375,10 +342,8 @@ class Element
         # The attribute value is nil
         return nil;
       end
-      dputs callz + "Getting expression '#{aValue}'"
       # remove all nils, them add one in at the end so [0] returns nil if empty
       q = (KeyPath.parse(aValue).map{|i|parentLoader.namespace[i]} - [nil] + [nil])[0]
-      dputs callz + "Parsed Expression! #{q};;;;#{q.inspect}"
       return q
     end
     return aValue;
@@ -482,7 +447,6 @@ class Element
           if (attrValue.length() == 0)
             raise LoadException.new("Missing expression reference.");
           end
-          dputs callz + "exprValue!' #{attrValue}'"
           expression = Expression.get(@namespace, KeyPath.parse(attrValue));
           if (expression.is_a? EventHandler)
             eventHandler = expression;
@@ -490,12 +454,12 @@ class Element
 
         end
         if (eventHandler == nil)
-          if (attrValue.length() == 0 || @scriptEngine == nil)
+          if (attrValue.length() == 0 || parentLoader.scriptEngine == nil)
             raise LoadException.new("Error resolving " + attribute.name + "='" + attribute.value +
                 "', either the event handler is not in the Namespace or there is an error in the script.");
           end
 
-          eventHandler = ScriptEventHandler.new(attrValue, @scriptEngine);
+          eventHandler = ScriptEventHandler.new(attrValue, parentLoader.scriptEngine);
         end
         # Add the handler
         if (eventHandler != nil)
@@ -546,6 +510,7 @@ end
 
 class EventHandlerWrapper
   include EventHandler
+  attr_reader :funcName
   def initialize(ctrl, funcName)
     @ctrl = ctrl
     @funcName = funcName
@@ -558,7 +523,51 @@ class EventHandlerWrapper
         @ctrl.send(@funcName, eventArgs)
       end
     else
-      dputs "Warning: method #{@funcName} was not found on controller #{@ctrl}"
+      puts "Warning: method #{@funcName} was not found on controller #{@ctrl}"
+    end
+  end
+end
+
+class ScriptEventHandler
+  include EventHandler
+  attr_reader :script, :scriptEngine
+  def initialize(script, scriptEngine)
+    @script = script;
+    @scriptEngine = scriptEngine;
+  end
+
+  def handle(event)
+    # Don't pollute the page namespace with values defined in the script
+    engineBindings = @scriptEngine.getBindings(ScriptContext::ENGINE_SCOPE);
+    localBindings = @scriptEngine.createBindings();
+    localBindings.put(FXL::EVENT_KEY, event);
+    @scriptEngine.setBindings(localBindings, ScriptContext::ENGINE_SCOPE);
+
+    # Execute the script
+    begin
+      @scriptEngine.eval(@script);
+    rescue ScriptException => exception
+      raise exception
     end
+
+    # Restore the original bindings
+    @scriptEngine.setBindings(engineBindings, ScriptContext::ENGINE_SCOPE);
   end
-end
+end
+
+class RelativeFXMLString < String
+  alias :super_inspect :inspect
+  def initialize(str, rel)
+    super(rel)
+    @rel = str
+  end
+  def inspect
+    "java.net.URL.new(__local_namespace['location'], #{@rel.inspect}).to_s"
+  end
+  def to_s
+    super
+  end
+  def class()
+    String
+  end
+end

data/lib/fxmlloader/fxml_jit_info.rb

@@ -0,0 +1,158 @@
+# * Copyright (c) 2013 Patrick Plenefisch
+# * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
+# *
+# * This code is free software; you can redistribute it and/or modify it
+# * under the terms of the GNU General Public License version 2 only, as
+# * published by the Free Software Foundation.  Oracle designates this
+# * particular file as subject to the "Classpath" exception as provided
+# * by Oracle in the LICENSE file that accompanied this code.
+# *
+# * This code is distributed in the hope that it will be useful, but WITHOUT
+# * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+# * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+# * version 2 for more details (a copy is included in the LICENSE file that
+# * accompanied this code).
+# *
+# * You should have received a copy of the GNU General Public License version
+# * 2 along with this work; if not, write to the Free Software Foundation,
+# * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
+# *
+
+require 'digest/sha1'
+require 'fileutils'
+
+def javafx
+  Java::javafx
+end
+
+Infinity = 1.0/0.0
+
+class FxmlJitInfo
+  include JRubyFX
+  def self.hash(file)
+    Digest::SHA1.hexdigest(File.read file)
+  end
+  def self.load_aot(file, cache, validate = true)
+    if validate
+      hash = hash(file)
+      f_hash = File.open(cache, "r", &:readline).strip
+      return false if "# #{hash} encoding: utf-8" != f_hash
+    end
+    hash = Digest::SHA1.hexdigest(File.basename file)
+    require cache
+    JRubyFX::GeneratedAssets.const_get("AOT#{hash}").new rescue nil
+  end
+  # TODO: store jit settings in here instead of $RB_* variables
+  attr_accessor :file_name, :raw_code, :jit_settings
+  def initialize(file_name, jit_settings=1, outfile=nil, cache_dir=nil,validate = true, opts = nil)
+    @file_name = file_name
+    @no_write = (opts && opts[:no_write]) || false
+    if @file_name.start_with? "file:"
+      @file_name = @file_name.gsub(/^file\:/, '')
+    elsif @file_name.start_with? "jar:"
+      @no_write = true
+    elsif @file_name.start_with? "compoundjar:"
+      @no_write = true
+    end
+    @jit_settings = jit_settings
+    @run_count = 0
+    @opts = opts
+    @outfile = if @outfile
+      outfile
+    else
+      cache_dir = cache_dir || File.join(File.dirname(@file_name), ".jrubyfx_cache")
+      FileUtils.mkpath(cache_dir) unless File.directory?(cache_dir) or @no_write
+      @f_hash = Digest::SHA1.hexdigest(File.basename @file_name)
+      File.join(cache_dir, "#{@f_hash}.rb")
+    end
+    if File.exist?(@outfile) && !(opts && opts[:force])
+      @compiled = self.class.load_aot(@file_name, @outfile, validate)
+      if @compiled
+        dputs "got #{file_name} from cache"
+      end
+    end
+  end
+  def hash
+    FxmlJitInfo.hash(@file_name)
+  end
+  def should_jit?
+    return false if @jit_settings == :no_jit || compiled?
+    return true if (@run_count += 1) >= @jit_settings
+  end
+  def compiled?
+    !!@compiled
+  end
+  def decompile
+    @compiled = nil
+  end
+  def __build_via_jit(__local_fxml_controller, __local_namespace, __local_jruby_ext)
+    @compiled.__build_via_jit(__local_fxml_controller, __local_namespace, __local_jruby_ext)
+  end
+  def compile(code=@raw_code)
+    @raw_code = code
+    # TODO: begin rescue end
+    full_code =  <<METHOD_DEF
+    def __build_via_jit(__local_fxml_controller, __local_namespace, __local_jruby_ext)
+      __local_fx_id_setter = lambda do |name, __i|
+        __local_namespace[name] = __i
+        __local_fxml_controller.instance_variable_set(("@\#{name}").to_sym, __i)
+      end
+#{code}
+    end
+METHOD_DEF
+    ;#)
+    unless @no_write
+      begin
+        jit_aot_cache(full_code)
+      rescue
+        p $!
+        jit_no_cache(full_code)
+      end
+    else
+      jit_no_cache(full_code)
+    end
+    if @opts && @opts[:compiled_hook]
+      @opts[:compiled_hook].call(@outfile)
+    end
+
+  end
+
+  def jit_no_cache(full_code)
+    dputs "JIT only, no aot for #{@file_name}"
+    self.instance_eval full_code
+    @compiled = true
+  end
+
+  def jit_aot_cache(full_code)
+    File.open(@outfile, "w") do |f|
+      hash = hash()
+      f << <<AOT
+# #{hash} encoding: utf-8
+# @@ 1
+
+########################### DO NOT MODIFY THIS FILE ###########################
+#       This file was automatically generated by JRubyFX-fxmlloader on        #
+# #{Time.now} for #{@file_name}
+########################### DO NOT MODIFY THIS FILE ###########################
+
+module JRubyFX
+  module GeneratedAssets
+    class AOT#{@f_hash}
+      include JRubyFX
+      #{full_code}
+      def hash
+        #{hash.inspect}
+      end
+      def compiled?
+        true
+      end
+    end
+  end
+end
+AOT
+    end
+    puts "saved #{@outfile} to cache"
+    require @outfile
+    @compiled = JRubyFX::GeneratedAssets.const_get("AOT#{@f_hash}").new rescue nil
+  end
+end