jrubyfx-master 1.1.1.brakemanpro1-java

data/lib/jrubyfx/part_imports.rb

@@ -0,0 +1,127 @@
+=begin
+JRubyFX - Write JavaFX and FXML in Ruby
+Copyright (C) 2013 The JRubyFX Team
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+=end
+
+require_relative 'utils'
+
+# Update load path to include the JavaFX runtime and fail nicely if we can't find it
+begin
+  if ENV['JFX_DIR']
+    $LOAD_PATH << ENV['JFX_DIR']
+  else #should we check for 1.7 vs 1.8? oh well, adding extra paths won't hurt anybody (maybe performance loading)
+    jfx_path = ENV_JAVA["sun.boot.library.path"]
+    $LOAD_PATH << if jfx_path.include? ":\\" and !jfx_path.include? "/" # can be tricked, but should work fine
+      #windows
+      jfx_path.gsub(/\\bin[\\]*$/i, "\\lib")
+    else
+      # *nix
+      jfx_path.gsub(/[\/\\][amdix345678_]+$/, "") # strip i386 or amd64 (including variants). TODO: ARM
+    end
+  end
+
+  # Java 8 at some point requires explicit toolkit/platform initialization
+  # before any controls can be loaded.
+  JRubyFX.load_fx
+
+  # Attempt to load a javafx class
+  Java.javafx.application.Application
+rescue  LoadError, NameError
+  puts "JavaFX runtime not found.  Please install Java 7u6 or newer or set environment variable JFX_DIR to the folder that contains jfxrt.jar "
+  puts "If you have Java 7u6 or later, this is a bug. Please report to the issue tracker on github. Include your OS version, 32/64bit, and architecture (x86, ARM, PPC, etc)"
+  exit -1
+end
+
+module JRubyFX
+  # If you need JavaFX, just include this module. Its sole purpose in life is to
+  # import all JavaFX stuff, plus a few useful Java classes (like Void)
+  module FXImports
+
+    # If something is missing, just java_import it in your code.
+    # And then ask us to put it in this list
+    ###### IMPORTANT LINE ##### (see rakefile, this is a magic line, don't delete)
+
+    ##
+    # This is the list of all classes in JavaFX that most apps should care about.
+    # It is a hashmaps with the leafs as arrays. Where a leaf also contains more
+    # packages, the hashmap key is "" (empty string). You can utilize this constant
+    # to save yourself some typing when adding code for most/all of the JavaFX
+    # classes by using either `Hash.flat_tree_inject` from jrubyfx/utils.rb or
+    # writing your own traversal function
+    #
+    JFX_CLASS_HIERARCHY = { :javafx => {
+        :animation => %w[Animation AnimationTimer FadeTransition FillTransition Interpolator KeyFrame KeyValue ParallelTransition PathTransition
+        PauseTransition RotateTransition ScaleTransition SequentialTransition StrokeTransition Timeline Transition TranslateTransition],
+        :application => ['Platform'],
+        :beans => {
+          :property => %w[SimpleBooleanProperty SimpleDoubleProperty SimpleFloatProperty SimpleIntegerProperty SimpleListProperty SimpleLongProperty SimpleMapProperty SimpleObjectProperty SimpleSetProperty SimpleStringProperty],
+          #TODO: import more
+          :value => ['ChangeListener']
+        },
+        :collections => ['FXCollections'],
+        :concurrent => %w[Worker Task Service],
+        :event => %w[Event ActionEvent EventHandler],
+        :fxml => ['Initializable', 'LoadException'],
+        :geometry => %w[HorizontalDirection HPos Insets Orientation Pos Rectangle2D Side VerticalDirection VPos],
+        :scene => {
+          '' => %w[Group Node Parent Scene],
+          :canvas => ['Canvas'],
+          :chart => %w[AreaChart Axis BarChart BubbleChart CategoryAxis Chart LineChart NumberAxis
+          PieChart ScatterChart StackedAreaChart StackedBarChart ValueAxis XYChart],
+          :control => %w[Accordion Button Cell CheckBox CheckBoxTreeItem CheckMenuItem ChoiceBox ColorPicker ComboBox ContextMenu Hyperlink
+          Label ListCell ListView Menu MenuBar MenuButton MenuItem Pagination PasswordField PopupControl ProgressBar ProgressIndicator RadioButton
+          RadioMenuItem ScrollBar ScrollPane Separator SeparatorMenuItem Slider SplitMenuButton SplitPane Tab TableView TableCell TableColumn TabPane TextArea
+          TextField TitledPane ToggleButton ToggleGroup ToolBar Tooltip TreeCell TreeItem TreeView ContentDisplay OverrunStyle SelectionMode],
+          :effect => %w[Blend BlendMode Bloom BlurType BoxBlur ColorAdjust ColorInput DisplacementMap DropShadow GaussianBlur Glow ImageInput
+          InnerShadow Lighting MotionBlur PerspectiveTransform Reflection SepiaTone Shadow],
+          :image => %w[Image ImageView PixelReader PixelWriter],
+          :input => %w[Clipboard ClipboardContent ContextMenuEvent DragEvent GestureEvent InputEvent InputMethodEvent KeyCode KeyEvent
+          Mnemonic MouseButton MouseDragEvent MouseEvent RotateEvent ScrollEvent SwipeEvent TouchEvent TransferMode ZoomEvent],
+          :layout => %w[AnchorPane BorderPane ColumnConstraints FlowPane GridPane HBox Pane Priority RowConstraints StackPane TilePane VBox],
+          :media => %w[AudioClip AudioEqualizer AudioTrack EqualizerBand Media MediaException
+          MediaErrorEvent MediaMarkerEvent MediaPlayer MediaView VideoTrack],
+          :paint => %w[Color CycleMethod ImagePattern LinearGradient Paint RadialGradient Stop],
+          :shape => %w[Arc ArcTo ArcType Circle ClosePath CubicCurve CubicCurveTo Ellipse FillRule HLineTo Line LineTo MoveTo Path PathElement
+          Polygon Polyline QuadCurve QuadCurveTo Rectangle Shape StrokeLineCap StrokeLineJoin StrokeType SVGPath VLineTo],
+          :text => %w[Font FontPosture FontSmoothingType FontWeight Text TextAlignment TextBoundsType],
+          :transform => %w[Affine Rotate Scale Shear Translate],
+          :web => ['WebView', 'HTMLEditor']
+        },
+        :stage => %w[DirectoryChooser FileChooser Modality Popup PopupWindow Screen Stage StageStyle Window WindowEvent],
+        :util => ['Duration']
+      }
+    }
+
+    $WRITE_OUT << <<HERE
+    def const_missing(c)
+      if LOCAL_NAME_MAP.has_key? c
+        java_import(LOCAL_NAME_MAP[c])[0]
+      else
+        super
+      end
+    end
+
+HERE
+
+    # Imports all the listed JavaFX classes
+    $WRITE_OUT << "LOCAL_NAME_MAP = { \n  "
+    $WRITE_OUT << (JFX_CLASS_HIERARCHY.flat_tree_inject do |res, name, values|
+        name = "#{name.to_s}."
+        name = "" if name == "."
+        res.concat(values.map{|i| "#{name}#{i}"})
+      end).map{|x| "#{x.split(".").last.to_sym.inspect} => #{x.inspect}"}.join(",\n  ")
+    $WRITE_OUT << "\n}\njava_import 'java.lang.Void'"
+  end
+end

data/lib/jrubyfx/utils/__ignore_java_stupid_rdoc.rb

@@ -0,0 +1,30 @@
+module Java #:nodoc: all
+  module javafx
+    module animation
+    end
+    module beans
+      module value
+      end
+    end
+    module scene
+      module chart
+      end
+      module control
+      end
+      module effect
+      end
+      module layout
+      end
+      module media
+      end
+      module paint
+      end
+      module shape
+      end
+      module transform
+      end
+    end
+    module stage
+    end
+  end
+end

data/lib/jrubyfx/utils/common_converters.rb

@@ -0,0 +1,223 @@
+=begin
+JRubyFX - Write JavaFX and FXML in Ruby
+Copyright (C) 2013 The JRubyFX Team
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+=end
+false # Do NOT delete this or it will make RDOC associate the copyright header with JRubyFX module
+
+module JRubyFX
+  module Utils
+    # Contains conversion utilities to ease Ruby => JavaFX coding
+    module CommonConverters
+      java_import 'javafx.scene.paint.Color'
+      java_import 'javafx.geometry.Insets'
+      java_import 'javafx.geometry.Rectangle2D'
+
+      # argument converter method name suffix
+      ARG_CONVERTER_SUFFIX = '_arg_converter'
+
+      # map of snake_cased colors to JavaFX Colors
+      NAME_TO_COLORS = {
+        'darkyellow' => Color.web('0xc0c000'),
+        'lightmagenta' => Color.web('0xffc0ff'),
+        'lightred' => Color.web('0xffc0c0'),
+      }.merge(Color.java_class.fields.inject({}) {|final, field|
+          final[field.name.downcase] = field.value(nil) # TODO: what is nil supposed to be?
+          final
+        })
+
+      ##
+      # Generate a converter for a map of supplied values.
+      def map_converter(map)
+        lambda do |value|
+          map.key?(value) ? map[value] : value
+        end
+      end
+
+      ##
+      # Generate a converter for an enum of the given class
+      def enum_converter(enum_class)
+        lambda do |value|
+          (JRubyFX::Utils::CommonConverters.map_enums(enum_class)[value.to_s] || value)
+        end
+      end
+
+      ##
+      # call-seq:
+      #   animation_converter_for :property_name, ...
+      #
+      # Generates an animation adapter for the given properties so you can specify
+      # transformations, etc with a hashmap of from, to values
+      # === Examples
+      #   animation_converter_for :value
+      #
+      #   ...
+      #
+      #   _my_type_(value: {0 => 360})
+      #
+      def animation_converter_for(*prop_names)
+        prop_names.each do |prop_name|
+          self.__send__(:define_method, prop_name.to_s + "=") do |hash|
+            method("from_#{prop_name}=").call hash.keys[0]
+            method("to_#{prop_name}=").call hash.values[0]
+          end
+        end
+      end
+
+      ##
+      # Allows you to specify you want a converter method created for the
+      # specified method where each listed converter corresponds to each
+      # argument for that method.  You can have n-arity lists for all
+      # matching Java overloads.  This mechanism means you may not always
+      # be able to specify all coercions you want.
+      # === Examples
+      #
+      #    coverter_for :new, [:none, :color]
+      #
+      # This method will define a method on the current class called
+      # *new_arg_converter* which will perform no argument coercion on
+      # the first argument and a color coercion on the second argument.
+      #
+      #    e = enum_converter(Java::javafx::scene::input::TransferMode)
+      #    converter_for :accept_transfer_modes &e
+      #
+      # This method will allow a catch-all converter to be used for all
+      # arities not specified.  In this case since no arities are given
+      # all arities will pass through this enum_converter.  This form
+      # is useful for single var_args signatures.
+      #
+      def converter_for(method_name, *converters, &default)
+       # puts "[converter for #{self}, #{method_name}]"
+        sheep = lambda do |direct, this, *values|
+          converter = converters.find { |e| e.length == values.length }
+          converter = Array.new(values.length, default) unless converter
+
+          # FIXME: Better error reporting on many things which can fail
+          i = 0
+          values = values.inject([]) do |s, value|
+            conv = converter[i]
+            if conv.kind_of? Proc
+              s << conv.call(value)
+            else
+              s << CONVERTERS[converter[i]].call(value)
+            end
+            i += 1
+            s
+          end
+          if direct
+            return this.method("set_" + method_name.to_s).call(*values)
+          else
+            return values
+          end
+        end
+        # define a setter for normal usage
+        unless method_name == :new
+          self.__send__(:define_method, method_name.to_s + "=") do |*values|
+            sheep.call(true, self, *values)
+          end
+        end
+        # define a build/with usage
+        self.__send__(:define_method, method_name.to_s + ARG_CONVERTER_SUFFIX) do |*values|
+          sheep.call(false, self, *values)
+        end
+      end
+
+      # Map of different kinds of known converters
+      CONVERTERS = {
+        :none => lambda { |value|
+          value
+        },
+        :color => lambda { |value|
+          new_value = NAME_TO_COLORS[value.to_s.gsub(/_/, "")]
+          if !new_value && value.kind_of?(Symbol)
+            raise ArgumentError.new("No such color: #{value.to_s}") 
+          end
+          new_value ? new_value : value
+        },
+        :rectangle2d => lambda { |value|
+          if value == :empty
+            Rectangle2D::EMPTY
+          elsif value.is_a? Array
+            Rectangle2D.new(*value)
+          else
+            value
+          end
+        },
+        :insets => lambda { |value|
+          if value == :empty
+            Insets::EMPTY
+          elsif value.is_a? Numeric
+            Insets.new(value)
+          elsif value.is_a? Array
+            # top/bottom, left/right
+            value = [value[0], value[1], value[0], value[1]] if value.size == 2
+            Insets.new(*value)
+          else
+            value
+          end
+        },
+      }
+
+      ENUM_CACHE = {}
+
+      # Store enum mapping overrides
+      ENUM_OVERRIDES = {Java::JavafxAnimation::PathTransition::OrientationType => {:orthogonal_to_tangent => :orthogonal},
+        Java::JavafxSceneEffect::BlendMode => {:src_over => :over, :src_atop => :atop, :color_dodge => :dodge, :color_burn => :burn},
+        Java::JavafxSceneControl::ContentDisplay => {:graphic_only => :graphic, :text_only => :text},
+        Java::JavafxSceneEffect::BlurType => {:one_pass_box => [:one, :one_pass], :two_pass_box => [:two, :two_pass], :three_pass_box => [:three, :three_pass]},
+        Java::JavafxStage::Modality => {:window_modal => :window, :application_modal => [:application, :app]}}
+
+      # sets the given overrides for the given class/enum
+      def self.set_overrides_for(enum_class,ovr)
+        ENUM_OVERRIDES[enum_class] = ovr
+      end
+
+      # Given a class, returns a hash of lowercase strings mapped to Java Enums
+      def self.map_enums(enum_class)
+        res = Hash[enum_class.java_class.enum_constants.map {|i| [i.to_s.downcase, i] }]
+        (ENUM_OVERRIDES[enum_class]||[]).each do |oldk, newks|
+          [newks].flatten.each do |newk|
+            res[newk.to_s] = res[oldk.to_s]
+          end
+        end
+        res
+      end
+
+      def self.parse_ruby_symbols(const, enum)
+        ENUM_CACHE[enum] = JRubyFX::Utils::CommonConverters.map_enums(enum) if  ENUM_CACHE[enum] == nil
+        ENUM_CACHE[enum][const.to_s] || const
+      end
+
+      def self.convert_args(values, converters)
+        converter = converters.find { |e| e.length == values.length }
+        converter = Array.new(values.length) unless converter
+
+        # FIXME: Better error reporting on many things which can fail
+        i = 0
+        values = values.inject([]) do |s, value|
+          conv = converter[i]
+          if conv.kind_of? Proc
+            s << conv.call(value)
+          else
+            s << CONVERTERS[converter[i]].call(value)
+          end
+          i += 1
+          s
+        end
+        return values
+      end
+    end
+
+  end
+end

data/lib/jrubyfx/utils/common_utils.rb

@@ -0,0 +1,72 @@
+=begin
+JRubyFX - Write JavaFX and FXML in Ruby
+Copyright (C) 2013 The JRubyFX Team
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+=end
+require_relative 'common_converters'
+
+module JRubyFX
+  # Several utilities that have no better place to go
+  module Utils
+    # Utilities to manage argument properties for build/with
+    module CommonUtils
+      ##
+      # If last argument of the arg list is a hash-like entity (:each_pair)
+      # then this strip off last argument and return it as second return
+      # value.
+      # === Examples:
+      #   split_args_from_properties(1, 2, a: 1) #=> [[1,2], {a: 1}]
+      #   split_args_from_properties(1, 2) #=> [[1,2], {}]
+      #
+      def split_args_from_properties(*args)
+        if !args.empty? and args.last.respond_to? :each_pair
+          properties = args.pop 
+        else 
+          properties = {}
+        end
+
+        return args, properties
+      end
+
+      ##
+      # Sets the hashmap given on the passed in object as a set of properties, 
+      # using converter if necessary.
+      #
+      def populate_properties(obj, properties)
+        properties.each_pair do |name, value|
+          obj.send(name.to_s + '=', *attempt_conversion(obj, name, value))
+        end
+        obj
+      end
+
+      ##
+      # Attempts to convert given value to JavaFX equvalent, if any, by calling
+      # obj.name_CommonConverters::ARG_CONVERTER_SUFFING, which is created by
+      # calling CommonConverters.converter_for in your class.
+      # See CommonConverters for current conversions
+      #
+      def attempt_conversion(obj, name, *values)
+        converter_method = name.to_s + 
+          JRubyFX::Utils::CommonConverters::ARG_CONVERTER_SUFFIX
+
+        # Each type can create their own converter method to coerce things
+        # like symbols into real values JavaFX likes.
+        if obj.respond_to? converter_method
+          values = obj.__send__ converter_method, *values
+        end
+        values
+      end
+    end
+  end
+end

data/lib/jrubyfx/utils/string_utils.rb

@@ -0,0 +1,48 @@
+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

data/lib/jrubyfx/utils.rb

@@ -0,0 +1,76 @@
+=begin
+JRubyFX - Write JavaFX and FXML in Ruby
+Copyright (C) 2013 The JRubyFX Team
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+=end
+
+# This feels kinda like a hack. If anyone has a better idea, please let me know
+
+# Standard ruby Hash class extensions
+class Hash
+
+  # call-seq:
+  #   flat_tree_inject() {|results, key, value| block} => array
+  #   flat_tree_inject(Hash) {|results, key, value| block} => hash
+  #
+  # Execute given block against all nodes in the hash tree, returning `results`.
+  # Similar to Hash#each except goes into all sub-Hashes
+  #
+  def flat_tree_inject(klass=Array,&block)
+    self.inject(klass.new) do |lres, pair|
+      if pair[1].is_a? Hash
+        pair[1] = pair[1].flat_tree_inject(klass, &block)
+      end
+      block.call(lres, *pair)
+    end
+  end
+end
+
+# Standard ruby String class extensions
+class String
+  # call-seq:
+  #   snake_case() => string
+  #
+  # Converts a CamelCaseString to a snake_case_string
+  #
+  #   "JavaFX".snake_case #=> "java_fx"
+  #
+  def snake_case
+    self.gsub(/::/, '/').
+    gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+    gsub(/([a-z\d])([A-Z])/,'\1_\2').
+    tr("-", "_").
+    downcase
+  end
+end
+
+module Enumerable
+  def map_find(&block)
+    m = {}
+    m[self.find do |i|
+      m[i] = block.call(i)
+    end]
+  end
+end
+
+module JRubyFX
+  def self.load_fx(force=false)
+    return if @already_loaded_fx and !force
+    @already_loaded_fx = true
+    java.util.concurrent.CountDownLatch.new(1).tap do |latch|
+      com.sun.javafx.application.PlatformImpl.startup { latch.countDown }
+      latch.await
+    end
+  end
+end

data/lib/jrubyfx/version.rb

@@ -0,0 +1,4 @@
+module JRubyFX
+  # Current gem version. Used in rake task.
+  VERSION='1.1.1.brakemanpro1'
+end

data/lib/jrubyfx.rb

@@ -0,0 +1,41 @@
+=begin
+JRubyFX - Write JavaFX and FXML in Ruby
+Copyright (C) 2013 The JRubyFX Team
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+=end
+
+if RUBY_VERSION.include? "1.8" or !JRUBY_VERSION
+  puts "JRubyFX requires JRuby to be in 1.9 mode"
+  exit -2
+end
+if Gem::Version.new(JRUBY_VERSION) < Gem::Version.new("1.7.4")
+  puts "Warning: JRuby 1.7.3 and prior have bugs that can cause strange errors. Do not submit any bug reports. Please use JRuby 1.7.4 or later."
+end
+
+require 'java' # for java_import
+require 'jruby/core_ext' # for the become_java!
+
+unless File.size? "#{File.dirname(__FILE__)}/jrubyfx/imports.rb"
+  puts "Please run `rake reflect` to generate the imports"
+  exit -1
+end
+# JRubyFX includes
+require_relative 'jrubyfx/imports'
+require_relative 'jrubyfx/module'
+require_relative 'jrubyfx/dsl'
+require_relative 'jrubyfx/dsl_control'
+JRubyFX::DSL.load_dsl # load it after we require the dsl package to not loop around
+require_relative 'jrubyfx/application'
+require_relative 'jrubyfx/controller'
+require_relative 'jrubyfx/java_fx_impl'