ruby-processing 1.0.9 → 1.0.10.1

data/lib/ruby-processing/config.rb

@@ -0,0 +1,6 @@
+require "yaml"
+
+module Processing
+  CONFIG_FILE_PATH = File.expand_path("~/.rp5rc")
+  CONFIG = (YAML::load_file(CONFIG_FILE_PATH) rescue {}).freeze 
+end

data/lib/ruby-processing/helper_methods.rb

@@ -0,0 +1,120 @@
+module Processing
+  module HelperMethods
+
+    # Nice block method to draw to a buffer.
+    # You can optionally pass it a width, a height, and a renderer.
+    # Takes care of starting and ending the draw for you.
+    def buffer(buf_width=width, buf_height=height, renderer=@render_mode)
+      buf = create_graphics(buf_width, buf_height, renderer)
+      buf.begin_draw
+      yield buf
+      buf.end_draw
+      buf
+    end
+
+    # A nice method to run a given block for a grid.
+    # Lifted from action_coding/Nodebox.
+    def grid(cols, rows, col_size=1, row_size=1)
+      (0...cols*rows).map do |i|
+        x = col_size * (i % cols)
+        y = row_size * i.div(cols)
+        yield x, y
+      end
+    end
+
+    # lerp_color takes three or four arguments, in Java that's two
+    # different methods, one regular and one static, so:
+    def lerp_color(*args)
+      args.length > 3 ? self.class.lerp_color(*args) : super(*args)
+    end
+
+    def color(*args)
+      a = args[0]
+      # convert to signed int
+      if args.length == 1 && a.is_a?(Fixnum) && a >= 2**31
+        args = [ a - 2**32 ]
+      end
+      super(*args)
+    end
+
+    # There's just so many functions in Processing,
+    # Here's a convenient way to look for them.
+    def find_method(method_name)
+      reg = Regexp.new("#{method_name}", true)
+      self.methods.sort.select {|meth| reg.match(meth)}
+    end
+
+    # 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)
+      fields.each {|f| @declared_fields[f] = java_class.declared_field(f) }
+    end
+
+    # By default, your sketch path is the folder that your sketch is in.
+    # If you'd like to do something fancy, feel free.
+    def set_sketch_path(path=nil)
+      field = @declared_fields['sketchPath']
+      field.set_value(java_self, path || SKETCH_ROOT)
+    end
+
+
+
+    # Fix java conversion problems getting the last key
+    # If it's ASCII, return the character, otherwise the integer
+    def key
+      int = @declared_fields['key'].value(java_self)
+      int < 256 ? int.chr : int
+    end
+
+    # Provide a convenient handle for the Java-space version of self.
+    def java_self
+      @java_self ||= Java.ruby_to_java self
+    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
+    def mouse_y;      mouseY;       end
+    def pmouse_x;     pmouseX;      end
+    def pmouse_y;     pmouseY;      end
+    def frame_count;  frameCount;   end
+    def mouse_button; mouseButton;  end
+    def key_code;     keyCode;      end
+
+
+    # Ensure that load_strings returns a real Ruby array
+    def load_strings(file_or_url)
+      loadStrings(file_or_url).to_a
+    end
+
+    # Writes an array of strings to a file, one line per string.
+    # This file is saved to the sketch's data folder
+    def save_strings(filename, strings)
+      saveStrings(filename, [strings].flatten.to_java(:String))
+    end
+
+    # frame_rate needs to support reading and writing
+    def frame_rate(fps = nil)
+      return @declared_fields['frameRate'].value(java_self) unless fps
+      super(fps)
+    end
+
+    # Is the mouse pressed for this frame?
+    def mouse_pressed?
+      Java.java_to_primitive(java_class.field("mousePressed").value(java_object))
+    end
+
+    # Is a key pressed for this frame?
+    def key_pressed?
+      Java.java_to_primitive(java_class.field("keyPressed").value(java_object))
+    end
+
+  end
+end

data/lib/ruby-processing/library_loader.rb

@@ -0,0 +1,140 @@
+module Processing
+  class LibraryLoader
+    attr_reader :sketchbook_library_path
+
+    def initialize
+      @sketchbook_library_path = File.join(find_sketchbook_path || "", "libraries")
+      @loaded_libraries = Hash.new(false)
+    end
+      
+    # Detect if a library has been loaded (for conditional loading)
+    def library_loaded?(library_name)
+      @loaded_libraries[library_name.to_sym]
+    end
+
+    # Load a list of Ruby or Java libraries (in that order)
+    # Usage: load_libraries :opengl, :boids
+    #
+    # If a library is put into a 'library' folder next to the sketch it will
+    # be used instead of the library that ships with Ruby-Processing.
+    def load_libraries(*args)
+      args.each do |lib|
+        loaded = load_ruby_library(lib) || load_java_library(lib)
+        raise LoadError.new "no such file to load -- #{lib}" if !loaded
+      end
+    end
+    alias :load_library :load_libraries
+
+    # For pure ruby libraries.
+    # The library should have an initialization ruby file
+    # of the same name as the library folder.
+    def load_ruby_library(library_name)
+      library_name = library_name.to_sym
+      return true if @loaded_libraries[library_name]
+      if Processing.online?
+        begin
+          return @loaded_libraries[library_name] = (require "library/#{library_name}/#{library_name}")
+        rescue LoadError => e
+          return false
+        end
+      else
+        path = get_library_path(library_name, "rb")
+        return false unless path
+        return @loaded_libraries[library_name] = (require "#{path}/#{library_name}")
+      end
+    end
+
+
+    # For pure java libraries, such as the ones that are available
+    # on this page: http://processing.org/reference/libraries/index.html
+    #
+    # P.S. -- Loading libraries which include native code needs to
+    # hack the Java ClassLoader, so that you don't have to
+    # futz with your PATH. But it's probably bad juju.
+    def load_java_library(library_name)
+      library_name = library_name.to_sym
+      return true if @loaded_libraries[library_name]
+      if Processing.online?
+        return @loaded_libraries[library_name] = !!(JRUBY_APPLET.get_parameter("archive").match(%r(#{library_name}))) 
+      end
+      path = get_library_path(library_name, "jar")
+      jars = Dir["#{path}/*.jar"]
+      return false if jars.empty?
+      jars.each {|jar| require jar }
+
+      platform_specific_library_paths = get_platform_specific_library_paths(path)
+      platform_specific_library_paths = platform_specific_library_paths.select do |path|
+        test(?d, path) && !Dir.glob(File.join(path, "*.{so,dll,jnilib}")).empty?
+      end
+
+      if !platform_specific_library_paths.empty?
+        platform_specific_library_paths << java.lang.System.getProperty("java.library.path")
+        new_library_path = platform_specific_library_paths.join(java.io.File.pathSeparator)
+
+        java.lang.System.setProperty("java.library.path", new_library_path)
+
+        field = java.lang.Class.for_name("java.lang.ClassLoader").get_declared_field("sys_paths")
+        if field
+          field.accessible = true
+          field.set(java.lang.Class.for_name("java.lang.System").get_class_loader, nil)
+        end
+      end
+      return @loaded_libraries[library_name] = true
+    end
+
+    def get_platform_specific_library_paths(basename)
+      bits = "32"
+      if 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" }.detect do |string, platform_|
+        java.lang.System.getProperty("os.name").index(string)
+      end
+      platform ||= "other"
+      [ platform, platform+bits ].collect { |p| File.join(basename, p) }
+    end
+
+    protected
+
+    def find_sketchbook_path
+      preferences_paths = []
+      sketchbook_paths = []
+      if sketchbook_path = CONFIG["sketchbook_path"]
+        return File.expand_path(sketchbook_path)
+      else
+        ["Application Data/Processing", "AppData/Roaming/Processing", 
+         "Library/Processing", "Documents/Processing", 
+         ".processing", "sketchbook"].each do |prefix|
+          path = "#{ENV["HOME"]}/#{prefix}"
+          pref_path = path+"/preferences.txt"
+          if test(?f, pref_path)
+            preferences_paths << pref_path
+          end
+          if test(?d, path)
+            sketchbook_paths << path
+          end
+        end
+        if !preferences_paths.empty?
+          matched_lines = File.readlines(preferences_paths.first).grep(/^sketchbook\.path=(.+)/) { $1 }
+          sketchbook_path = matched_lines.first
+        else
+          sketchbook_path = sketchbook_paths.first
+        end
+        return sketchbook_path
+      end
+    end
+    
+    def get_library_path(library_name, extension)
+      [ "#{SKETCH_ROOT}/library/#{library_name}", 
+        "#{RP5_ROOT}/library/#{library_name}/library", 
+        "#{RP5_ROOT}/library/#{library_name}", 
+        "#{@sketchbook_library_path}/#{library_name}/library",
+        "#{@sketchbook_library_path}/#{library_name}" 
+      ].detect do |path| 
+        File.exists?("#{path}/#{library_name}.#{extension}")
+      end
+    end
+  end
+end

data/lib/ruby-processing/runner.rb

@@ -1,5 +1,6 @@
 require 'ostruct'
 require 'fileutils'
+require 'ruby-processing/config'
 
 module Processing
 
@@ -8,16 +9,40 @@ module Processing
   class Runner
 
     HELP_MESSAGE = <<-EOS
+  Version: #{Processing::VERSION}
 
   Ruby-Processing is a little shim between Processing and JRuby that helps
   you create sketches of code art.
 
   Usage:
-    rp5 [run | watch | live | create | app | applet | unpack] path/to/sketch
+    rp5 [run | watch | live | create [width height] | app | applet | unpack] path/to/sketch
+
+    run:        run sketch once
+    watch:      watch for changes on the file and relaunch it on the fly
+    live:       launch sketch and give an interactive IRB shell
+    create:     create new sketch. Use --bare to generate simpler sketches without a class
+    app:        create an application version of the sketch
+    applet:     create an applet version of the sketch
+    unpack:     unpack samples or library
+
+  Common options:
+    --jruby:    passed, use the installed version of jruby, instead of
+                our vendored jarred one (useful for gems).
+  
+  Configuration file:
+    A YAML configuration file is located at #{Processing::CONFIG_FILE_PATH}
+    
+    Possible options are:
+
+      java_args:        pass additionnals arguments to Java VM upon launching. 
+                        Useful for increasing available memory (for example:
+                        -Xms256m -Xmx256m) or force 32 bits mode (-d32).
+      sketchbook_path:  specify Processing sketchbook path to load additionnal 
+                        libraries
 
   Examples:
     rp5 unpack samples
-    rp5 run samples/jwishy.rb
+    rp5 run samples/contributed/jwishy.rb
     rp5 create some_new_sketch --bare 640 480
     rp5 watch some_new_sketch.rb
     rp5 applet some_new_sketch.rb
@@ -137,8 +162,13 @@ module Processing
     # then type them into 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 = dock_icon
-      args += File.read(arg_file).split(/\s+/) if File.exists?(arg_file)
+      args = []
+      args += dock_icon
+      if File.exists?(arg_file)
+        args += File.read(arg_file).split(/\s+/)
+      elsif CONFIG["java_args"]
+        args += CONFIG["java_args"].split(/\s+/)
+      end
       args.map! {|arg| "-J#{arg}" }            if @options.jruby
       args
     end

data/lib/ruby-processing/runners/base.rb

@@ -1,5 +1,5 @@
 $LOAD_PATH << File.expand_path(File.dirname(__FILE__) + "/../../")
-SKETCH_PATH = ARGV.shift
+SKETCH_PATH = ARGV.shift unless defined? SKETCH_PATH
 SKETCH_ROOT = File.dirname(SKETCH_PATH) unless defined? SKETCH_ROOT
 
 require 'ruby-processing'
@@ -7,7 +7,7 @@ require 'ruby-processing/app'
 
 
 module Processing
-  
+
   # For use with "bare" sketches that don't want to define a class or methods
   SKETCH_TEMPLATE = <<-EOS
     class Sketch < Processing::App
@@ -22,26 +22,25 @@ module Processing
       <% end %>
     end
   EOS
-  
+
   # This method is the common entry point to run a sketch, bare or complete.
   def self.load_and_run_sketch
     source = self.read_sketch_source
     has_sketch = !!source.match(/^[^#]*< Processing::App/)
     has_methods = !!source.match(/^[^#]*(def\s+setup|def\s+draw)/)
-    
+
     if has_sketch
       load SKETCH_PATH
       Processing::App.sketch_class.new if !$app
-      return
     else
       require 'erb'
       code = ERB.new(SKETCH_TEMPLATE).result(binding)
-      Object.class_eval code, SKETCH_PATH, 0
-      Processing::App.sketch_class.new if !$app
+      Object.class_eval code, SKETCH_PATH, -1
+      Processing::App.sketch_class.new
     end
   end
-  
-  
+
+
   # Read in the sketch source code. Needs to work both online and offline.
   def self.read_sketch_source
     if Processing.online?
@@ -59,5 +58,5 @@ module Processing
     end
     source
   end
-  
-end
+
+end

data/lib/ruby-processing/runners/live.rb

@@ -9,4 +9,4 @@ ARGV.clear # So that IRB doesn't try to load them as files.
 
 require 'irb'
 IRB.setup(__FILE__)
-IRB.start
+IRB.start

data/lib/ruby-processing/runners/run.rb

@@ -4,4 +4,4 @@
 root = defined?(JRUBY_APPLET) ? 'ruby-processing/runners' : File.dirname(__FILE__)
 require "#{root}/base.rb"
 
-Processing.load_and_run_sketch
+Processing.load_and_run_sketch

data/lib/ruby-processing/runners/watch.rb

@@ -8,10 +8,8 @@ module Processing
 
     # Sic a new Processing::Watcher on the sketch
     def initialize
-      @file = SKETCH_PATH
+      reload_files_to_watch
       @time = Time.now
-      # Doesn't work well enough for now.
-      # record_state_of_ruby
       start_watching
     end
 
@@ -19,22 +17,18 @@ module Processing
     # Kicks off a thread to watch the sketch, reloading Ruby-Processing
     # and restarting the sketch whenever it changes.
     def start_watching
-      @runner = Thread.start { report_errors { Processing.load_and_run_sketch } } unless $app
-      thread = Thread.start do
-        loop do
-          file_mtime = File.stat(@file).mtime
-          if file_mtime > @time
-            @time = file_mtime
-            wipe_out_current_app!
-            # Taking it out the reset until it can be made to work more reliably
-            # rewind_to_recorded_state
-            GC.start
-            @runner = Thread.start { report_errors { Processing.load_and_run_sketch } }
-          end
-          sleep 0.33
+      start_runner
+      loop do
+        if @files.detect { |file| File.exists?(file) && File.stat(file).mtime > @time }
+          puts "reloading sketch..."
+          $app && $app.close
+          @time = Time.now
+          GC.start
+          start_runner
+          reload_files_to_watch
         end
+        sleep 0.33
       end
-      thread.join
     end
 
     # Convenience function to report errors when loading and running a sketch,
@@ -47,70 +41,18 @@ module Processing
       puts e.backtrace.join("\n")
     end
 
-    # Used to completely remove all traces of the current sketch,
-    # so that it can be loaded afresh. Go down into modules to find it, even.
-    def wipe_out_current_app!
-      @runner.kill if @runner.alive?
-      app = $app
-      return unless app
-      app.no_loop
-      # Wait for the animation thread to finish rendering
-      sleep 0.075
-      app.close
-      constant_names = app.class.to_s.split(/::/)
-      app_class_name = constant_names.pop
-      obj = constant_names.inject(Object) {|o, name| o.send(:const_get, name) }
-      obj.send(:remove_const, app_class_name)
-    end
-
-    # The following methods were intended to make the watcher clean up all code
-    # loaded in from the sketch, gems, etc, and have them be reloaded properly
-    # when the sketch is.... but it seems that this is neither a very good idea
-    # or a very possible one. If you can make the scheme work, please do,
-    # otherwise the following methods will probably be removed soonish.
-
-    # Do the best we can to take a picture of the current Ruby interpreter.
-    # For now, this means top-level constants and loaded .rb files.
-    def record_state_of_ruby
-      @saved_constants  = Object.send(:constants).dup
-      @saved_load_paths = $LOAD_PATH.dup
-      @saved_features   = $LOADED_FEATURES.dup
-      @saved_globals    = Kernel.global_variables.dup
-    end
-
-
-    # Try to go back to the recorded Ruby state.
-    def rewind_to_recorded_state
-      new_constants  = Object.send(:constants).reject {|c| @saved_constants.include?(c) }
-      new_load_paths = $LOAD_PATH.reject {|p| @saved_load_paths.include?(p) }
-      new_features   = $LOADED_FEATURES.reject {|f| @saved_features.include?(f) }
-      new_globals    = Kernel.global_variables.reject {|g| @saved_globals.include?(g) }
-
-      Processing::App.recursively_remove_constants(Object, new_constants)
-      new_load_paths.each {|p| $LOAD_PATH.delete(p) }
-      new_features.each {|f| $LOADED_FEATURES.delete(f) }
-      new_globals.each do |g|
-        begin
-          eval("#{g} = nil") # There's no way to undef a global variable in Ruby
-        rescue NameError => e
-          # Some globals are read-only, and we can't set them to nil.
+    def start_runner 
+      @runner.kill if @runner && @runner.alive?
+      @runner = Thread.start do 
+        report_errors do 
+          Processing.load_and_run_sketch
         end
       end
     end
 
-
-    # Used to clean up declared constants in code that needs to be reloaded.
-    def recursively_remove_constants(base, constant_names)
-      constants = constant_names.map {|name| base.const_get(name) }
-      constants.each_with_index do |c, i|
-        java_obj = Java::JavaLang::Object
-        constants[i] = constant_names[i] = nil if c.respond_to?(:ancestors) && c.ancestors.include?(java_obj)
-        constants[i] = nil if !c.is_a?(Class) && !c.is_a?(Module)
-      end
-      constants.each {|c| recursively_remove_constants(c, c.constants) if c }
-      constant_names.each {|name| base.send(:remove_const, name.to_sym) if name }
+    def reload_files_to_watch
+      @files = ([SKETCH_PATH] + Dir.glob(File.dirname(SKETCH_PATH) + "/*.rb")).uniq
     end
-
   end
 end