ruby-processing 2.6.3 → 2.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 591fe4a424a740865ae79dbf1060221b692ea81a
-  data.tar.gz: 5adb639c8832800b21f0877b33ddd366bfe73f44
+  metadata.gz: 3264280ea59ec35abe73d1b21727480c68f91415
+  data.tar.gz: 3711a7a054800bb6aa9e9aaf2f05da60912776c9
 SHA512:
-  metadata.gz: ed7651d8224f586ba6fc194cee99bdbef01248485cbabc3b92cb31514e746d1fa74a65d72fb8b8c8f189df56484728b2afa1984a5711359bd29761e9acadd688
-  data.tar.gz: 050764df809b66e1b7434368d7135309d2e61d6d842c6f976dacac90be50affd027d10031c634903d1057e77fe7593d7cf54739a00c4985838d0d9211230d101
+  metadata.gz: 2e15cc2bbbd11527c844f60fe43e36e8e13db991f9d14a0bed1622c8796449c0934280fe6b5405b41179fb641d0ed01cd2b71f295207c5437d50e34074dc86e9
+  data.tar.gz: 080e198e2d07dfc0406342ad7decd8b4a9956496a74cbc158a152dfed6d51357bea2a2bf85f4710b18b9a901a767a8abcf03bddff759998da317d4674f9b832f

data/lib/ruby-processing/app.rb

@@ -7,16 +7,12 @@ require_relative '../ruby-processing/helper_methods'
 require_relative '../ruby-processing/library_loader'
 require_relative '../ruby-processing/config'
 
-Dir["#{Processing::RP_CONFIG['PROCESSING_ROOT']}/core/library/\*.jar"].each { |jar| require jar }
-
-# Include some core processing classes that we'd like to use:
-%w(PApplet PConstants PFont PImage PShape PShapeOBJ PShapeSVG PStyle
-   PGraphicsJava2D PGraphics PFont PVector PMatrix2D PMatrix3D).each do |klass|
-  java_import "processing.core.#{klass}"
+Dir["#{Processing::RP_CONFIG['PROCESSING_ROOT']}/core/library/\*.jar"].each do
+|jar|
+  require jar
 end
 
 module Processing
-
   # This is the main Ruby-Processing class, and is what you'll
   # inherit from when you create a sketch. This class can call
   # all of the methods available in Processing, and has two
@@ -24,10 +20,26 @@ module Processing
   # should define in your sketch. 'setup' will be called one
   # time when the sketch is first loaded, and 'draw' will be
   # called constantly, for every frame.
+
+  # Include some core processing classes that we'd like to use:
+  include_package 'processing.core' 
+  
+  # Watch the definition of these methods, to make sure
+  # that Processing is able to call them during events.
+  METHODS_TO_ALIAS ||= {
+    mouse_pressed: :mousePressed,
+    mouse_dragged: :mouseDragged,
+    mouse_clicked: :mouseClicked,
+    mouse_moved: :mouseMoved,
+    mouse_released: :mouseReleased,
+    key_pressed: :keyPressed,
+    key_released: :keyReleased,
+    key_typed: :keyTyped
+  }
+  
   class App < PApplet
     include Math
     include HelperMethods
-
     # Alias some methods for familiarity for Shoes coders.
     # attr_accessor :frame, :title
     alias_method :oval, :ellipse
@@ -35,24 +47,11 @@ module Processing
     alias_method :rgb, :color
     alias_method :gray, :color
 
-
     # When certain special methods get added to the sketch, we need to let
     # Processing call them by their expected Java names.
     def self.method_added(method_name) #:nodoc:
-      # Watch the definition of these methods, to make sure
-      # that Processing is able to call them during events.
-      methods_to_alias = {
-        mouse_pressed:  :mousePressed,
-        mouse_dragged:  :mouseDragged,
-        mouse_clicked:  :mouseClicked,
-        mouse_moved:    :mouseMoved,
-        mouse_released: :mouseReleased,
-        key_pressed:    :keyPressed,
-        key_released:   :keyReleased,
-        key_typed:      :keyTyped
-      }
-      if methods_to_alias.key?(method_name)
-        alias_method methods_to_alias[method_name], method_name
+      if METHODS_TO_ALIAS.key?(method_name)
+        alias_method METHODS_TO_ALIAS[method_name], method_name
       end
     end
 
@@ -60,7 +59,7 @@ module Processing
     class << self
       attr_accessor :sketch_class
     end
-    
+
     def sketch_class
       self.class.sketch_class
     end
@@ -112,10 +111,11 @@ module Processing
       mix_proxy_into_inner_classes
       # @started = false
 
-      java.lang.Thread.default_uncaught_exception_handler = proc do |_thread_, exception|
+      java.lang.Thread.default_uncaught_exception_handler = proc do
+      |_thread_, exception|
         puts(exception.class.to_s)
         puts(exception.message)
-        puts(exception.backtrace.map { |trace| '\t' + trace })
+        puts(exception.backtrace.map { |trace| "\t#{trace}" })
         close
       end
 
@@ -127,9 +127,10 @@ module Processing
 
       args = []
       @width, @height = options[:width], options[:height]
-      if @full_screen || options[:full_screen]
-        @full_screen = true
-        args << '--present'
+      if options[:full_screen]
+        present = true
+        args << '--full-screen'
+        args << "--bgcolor=#{options[:bgcolor]}" if options[:bgcolor]
       end
       @render_mode  ||= JAVA2D
       xc = Processing::RP_CONFIG['X_OFF'] ||= 0
@@ -137,20 +138,23 @@ module Processing
       x = options[:x] || xc
       y = options[:y] || yc
       args << "--location=#{x},#{y}"  # important no spaces here
-      title = options[:title] || File.basename(SKETCH_PATH).sub(/(\.rb)$/, '').titleize
+      title = options[:title] ||
+      File.basename(SKETCH_PATH).sub(/(\.rb)$/, '').titleize
       args << title
-      PApplet.run_sketch(args, self)
+      PApplet.run_sketch(args.to_java(:string), self)
     end
 
     def size(*args)
       w, h, mode       = *args
-      @width           ||= w     unless @width
-      @height          ||= h     unless @height
-      @render_mode     ||= mode  unless @render_mode
-      if [P3D, P2D].include? @render_mode
-        # Include some opengl processing classes that we'd like to use:
-        %w(FontTexture FrameBuffer LinePath LineStroker PGL PGraphics2D PGraphics3D PGraphicsOpenGL PShader PShapeOpenGL Texture).each do |klass|
-          java_import "processing.opengl.#{klass}"
+      @width           ||= w     
+      @height          ||= h     
+      @render_mode     ||= mode  
+      if /opengl/ =~ mode
+        # Include processing opengl classes that we'd like to use:
+        %w(FontTexture FrameBuffer LinePath LineStroker PGL
+         PGraphics2D PGraphics3D PGraphicsOpenGL PShader
+         PShapeOpenGL Texture).each do |klass|
+         java_import "processing.opengl.#{klass}"        
         end
       end
       super(*args)
@@ -160,7 +164,7 @@ module Processing
       nil
     end
 
-    # Make sure we set the size if we set it before we start the animation thread.
+    # Set the size if we set it before we start the animation thread.
     def start
       size(@width, @height) if @width && @height
       super()
@@ -197,27 +201,31 @@ module Processing
   # unfettered access to the methods defined in the surrounding class.
   module Proxy
     include Math
-    # Generate the list of method names that we'd like to proxy for inner classes.
+    # Generate a list of method names to proxy for inner classes.
     # Nothing camelCased, nothing __internal__, just the Processing API.
     def self.desired_method_names(inner_class)
       bad_method = /__/    # Internal JRuby methods.
       unwanted = PApplet.superclass.instance_methods + Object.instance_methods
       unwanted -= %w(width height cursor create_image background size resize)
       methods = Processing::App.public_instance_methods
-      methods.reject { |m| unwanted.include?(m) || bad_method.match(m) || inner_class.method_defined?(m) }
+      methods.reject do |m|
+        unwanted.include?(m) ||
+        bad_method.match(m) ||
+        inner_class.method_defined?(m)
+      end
     end
 
     # Proxy methods through to the sketch.
     def self.proxy_methods(inner_class)
       code = desired_method_names(inner_class).reduce('') do |rcode, method|
         rcode << <<-EOS
-        def #{method}(*args, &block)                # def rect(*args, &block)
-        if block_given?                           #   if block_given?
-        $app.send :'#{method}', *args, &block   #     $app.send(:rect, *args, &block)
-        else                                      #   else
-        $app.#{method} *args                    #     $app.rect *args
-        end                                       #   end
-        end                                         # end
+        def #{method}(*args, &block)           # def rect(*args, &block)
+        if block_given?                        #   if block_given?
+        $app.send :'#{method}', *args, &block  #   ...
+        else                                   #   else
+        $app.#{method} *args                   #     $app.rect *args
+        end                                    #   end
+        end                                    # end
         EOS
       end
       inner_class.class_eval(code)

data/lib/ruby-processing/helper_methods.rb

@@ -122,7 +122,7 @@ module Processing
 
     # Uses PImage class method under hood
     def blend_color(c1, c2, mode)
-      PImage.blendColor(c1, c2, mode)
+      Java::ProcessingCore::PImage::blendColor(c1, c2, mode)
     end
 
     # There's just so many functions in Processing,
@@ -135,9 +135,9 @@ module Processing
     # Proxy over a list of Java declared fields that have the same name as
     # some methods. Add to this list as needed.
     def proxy_java_fields
-      @declared_fields = {}
       fields = %w(sketchPath key frameRate frame mousePressed keyPressed)
-      fields.each { |f| @declared_fields[f] = java_class.declared_field(f) }
+      methods  = fields.map { |field| java_class.declared_field(field) }
+      @declared_fields = Hash[fields.zip(methods)]
     end
 
     # By default, your sketch path is the folder that your sketch is in.
@@ -159,26 +159,25 @@ module Processing
       @java_self ||= to_java(Java::ProcessingCore::PApplet)
     end
 
-
     # Get the sketch path
     def sketch_path
       @declared_fields['sketchPath'].value(java_self)
     end
 
     # Fields that should be made accessible as under_scored.
-    def mouse_x;      mouseX;       end
+    define_method(:mouse_x) { mouseX }
 
-    def mouse_y;      mouseY;       end
+    define_method(:mouse_y) { mouseY }
 
-    def pmouse_x;     pmouseX;      end
+    define_method(:pmouse_x) { pmouseX }
 
-    def pmouse_y;     pmouseY;      end
+    define_method(:pmouse_y) { pmouseY }
 
-    def frame_count;  frameCount;   end
+    define_method(:frame_count) { frameCount }
 
-    def mouse_button; mouseButton;  end
+    define_method(:mouse_button) { mouseButton }
 
-    def key_code;     keyCode;      end
+    define_method(:key_code) { keyCode }
 
     # Ensure that load_strings returns a real Ruby array
     def load_strings(file_or_url)
@@ -207,4 +206,4 @@ module Processing
       @declared_fields['keyPressed'].value(java_self)
     end
   end
-end
+end

data/lib/ruby-processing/library_loader.rb

@@ -73,20 +73,25 @@ module Processing
       end
       @loaded_libraries[library_name] = true
     end
+    
+    def platform
+      match = %w(Mac Linux Windows).find do |os|
+        java.lang.System.getProperty('os.name').index(os)
+      end
+      return 'other' unless match
+      return match.downcase unless match =~ /Mac/
+      return 'macosx'
+    end
 
     def get_platform_specific_library_paths(basename)
       bits = 'universal'  # for MacOSX, but does this even work, or does Mac return '64'?
       if java.lang.System.getProperty('sun.arch.data.model') == '32' ||
-        java.lang.System.getProperty('java.vm.name').index('32')
+          java.lang.System.getProperty('java.vm.name').index('32')
         bits = '32'
       elsif java.lang.System.getProperty('sun.arch.data.model') == '64' ||
-        java.lang.System.getProperty('java.vm.name').index('64')
-        bits = '64'
-      end
-      _match_string_, platform = {'Mac' => 'macosx', 'Linux' => 'linux', 'Windows' => 'windows' }.find do |string, _platform_|
-        java.lang.System.getProperty('os.name').index(string)
+          java.lang.System.getProperty('java.vm.name').index('64')
+        bits = '64' unless platform =~ /macosx/
       end
-      platform ||= 'other'
       [platform, platform + bits].map { |p| File.join(basename, p) }
     end
 
@@ -122,8 +127,8 @@ module Processing
         return File.expand_path(sketchbook_path)
       else
         ["'Application Data/Processing'", 'AppData/Roaming/Processing',
-         'Library/Processing', 'Documents/Processing',
-         '.processing', 'sketchbook'].each do |prefix|
+          'Library/Processing', 'Documents/Processing',
+          '.processing', 'sketchbook'].each do |prefix|
           spath = "#{ENV['HOME']}/#{prefix}"
           pref_path = spath + '/preferences.txt'
           if test(?f, pref_path)
@@ -134,7 +139,11 @@ module Processing
           end
         end
         unless preferences_paths.empty?
-          matched_lines = File.readlines(preferences_paths.first).grep(/^sketchbook\.path=(.+)/) { $1 }
+          lines = File.readlines(preferences_paths.first)
+          regex1=/^sketchbook\.path=(.+)/           # processing-2.0
+          regex2=/^sketchbook\.path\.three=(.+)/    # processing-3.0
+          matched_lines = lines.grep(regex1) { $1 } unless $1 == ''
+          matched_lines = lines.grep(regex2) { $1 } unless $1 == ''
           sketchbook_path = matched_lines.first
         else
           sketchbook_path = sketchbook_paths.first

data/lib/ruby-processing/runner.rb

@@ -10,7 +10,7 @@ module Processing
   # Utility class to handle the different commands that the 'rp5' command
   # offers. Able to run, watch, live, create, app, and unpack
   class Runner
-    HELP_MESSAGE = <<-EOS
+    HELP_MESSAGE ||= <<-EOS
     Version: #{RubyProcessing::VERSION}
 
     Ruby-Processing is a little shim between Processing and JRuby that helps
@@ -43,6 +43,17 @@ module Processing
 
     EOS
 
+    WIN_PATTERNS = [
+      /bccwin/i,
+      /cygwin/i,
+      /djgpp/i,
+      /mingw/i,
+      /mswin/i,
+      /wince/i
+    ]
+
+    attr_reader :os
+
     # Start running a ruby-processing sketch from the passed-in arguments
     def self.execute
       runner = new
@@ -60,7 +71,6 @@ module Processing
       when 'app'    then app(@options.path)
       when 'setup'  then setup(@options.path)
       when /-v/     then show_version
-      when /-h/     then show_help
       else
         show_help
       end
@@ -116,29 +126,29 @@ module Processing
     end
 
     def setup(choice)
-      usage = 'Usage: rp5 setup [check | install | unpack_samples]'
-      installed = File.exist?("#{RP5_ROOT}/lib/ruby/jruby-complete.jar")
       proc_root = File.exist?("#{ENV['HOME']}/.rp5rc")
       case choice
       when /check/
-        check(proc_root, installed)
+        check(proc_root, File.exist?("#{RP5_ROOT}/lib/ruby/jruby-complete.jar"))
       when /install/
-        system "cd #{RP5_ROOT}/vendors && rake"
-        unless proc_root
-          set_processing_root
-          warn 'PROCESSING_ROOT set optimistically, run check to confirm'
-        end
+        install(proc_root)
       when /unpack_samples/
-        require 'fileutils'
-        FileUtils.cp_r("#{RP5_ROOT}/samples", "#{Dir.pwd}/rp_samples")
+        system "cd #{RP5_ROOT}/vendors && rake unpack_samples"
       else
-        puts usage
+        puts 'Usage: rp5 setup [check | install | unpack_samples]'
       end
     end
 
-    def check(proc_root, installed)
+    def install(root_exist)
+      system "cd #{RP5_ROOT}/vendors && rake"
+      return if root_exist
+      set_processing_root
+      warn 'PROCESSING_ROOT set optimistically, run check to confirm'
+    end
+
+    def check(root_exist, installed)
       show_version
-      root = '  PROCESSING_ROOT = Not Set!!!' unless proc_root
+      root = '  PROCESSING_ROOT = Not Set!!!' unless root_exist
       root ||= "  PROCESSING_ROOT = #{Processing::RP_CONFIG['PROCESSING_ROOT']}"
       jruby = Processing::RP_CONFIG['JRUBY']
       x_off = Processing::RP_CONFIG['X_OFF']
@@ -175,16 +185,25 @@ module Processing
       warn('The --jruby flag is no longer required') if @options.jruby
       @options.nojruby = true if Processing::RP_CONFIG['JRUBY'] == 'false'
       java_args = discover_java_args(sketch)
-      command = @options.nojruby ?
-        ['java', java_args, '-cp', jruby_complete, 'org.jruby.Main', runner, sketch, args].flatten :
-        ['jruby', java_args, runner, sketch, args].flatten
+      if @options.nojruby
+        command = ['java',
+                   java_args,
+                   '-cp',
+                   jruby_complete,
+                   'org.jruby.Main',
+                   runner,
+                   sketch,
+                   args].flatten
+      else
+        command = ['jruby', java_args, runner, sketch, args].flatten
+      end
       exec(*command)
       # exec replaces the Ruby process with the JRuby one.
     end
 
     # If you need to pass in arguments to Java, such as the ones on this page:
     # http://docs.oracle.com/javase/1.5.0/docs/tooldocs/windows/java.html
-    # then type them into a java_args.txt in your data directory next to your sketch.
+    # add them to a java_args.txt in your data directory next to your sketch.
     def discover_java_args(sketch)
       arg_file = "#{File.dirname(sketch)}/data/java_args.txt"
       args = []
@@ -212,29 +231,25 @@ module Processing
       end
     end
 
-    def os
-      @os ||= host_os = RbConfig::CONFIG['host_os']
-      case host_os
-      when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
-        :windows
-      when /darwin|mac os/
-        :macosx
-      when /linux/
-        :linux
-      when /solaris|bsd/
-        :unix
+    def host_os
+      detect_os = RbConfig::CONFIG['host_os']
+      case detect_os
+      when /mac|darwin/ then :mac
+      when /linux/ then :linux
+      when /solaris|bsd/ then :unix
       else
-        fail "unknown os: #{host_os.inspect}"
+        WIN_PATTERNS.find { |r| detect_os =~ r }
+        fail "unknown os: #{detect_os.inspect}" if Regexp.last_match.nil?
+        :windows
       end
     end
 
     # Optimistically set processing root
     def set_processing_root
       require 'psych'
-      os
       data = {}
       path = File.expand_path("#{ENV['HOME']}/.rp5rc")
-      if @os == :macosx
+      if host_os == :mac
         data['PROCESSING_ROOT'] = '/Applications/Processing.app/Contents/Java'
       else
         root = "#{ENV['HOME']}/processing-2.2.1"
@@ -246,9 +261,8 @@ module Processing
 
     # On the Mac, we can display a fat, shiny ruby in the Dock.
     def dock_icon
-      os
       icon = []
-      if @os == :mac
+      if host_os == :mac
         icon << '-Xdock:name=Ruby-Processing'
         icon << "-Xdock:icon=#{RP5_ROOT}/lib/templates/application/Contents/Resources/sketch.icns"
       end
@@ -256,4 +270,3 @@ module Processing
     end
   end # class Runner
 end # module Processing
-