ruby-processing 1.0.1

data/CHANGELOG

@@ -0,0 +1,137 @@
+v1.0.1 Gemmin' it up.
+  * The smallest version bump is the biggest change:
+    Ruby-Processing has undergone a great refactor, kicked off by
+    Peter Gassner's initial efforts to make a gem out of it. Now
+    available as a real RubyGem.
+    
+  * Changes all around: The main interface to Ruby-Processing is now
+    through the 'rp5' command. Try rp5 --help to get started.
+
+  * has_slider has been superseded by control_panel, a more full-
+    fledged library for controlling aspects of your sketch. Read
+    how to use it on the wiki, or check out jwishy.rb
+
+v1.0. Ruby-Processing goes 1.0 with Processing 1.0
+  * Processing updated to 1.0.1 (congrats to the Processing team),
+    and JRuby updated to the latest trunk. Most sketches run a good
+    bit faster now.
+    
+  * Ruby-Processing now comes with many default libraries: Boids, DXF,
+    Javascript, Minim, Net, OpenGL, PDF, Serial, Slider, and Video
+    are now included in the download.
+    
+  * has_slider moved out into an included ruby library.
+
+v0.9. Multi-platform Application export, live coding, and more.
+  * Inspired by NodeBox, Ruby-Processing now sports the ability 
+    to have sliders control numeric variables in your sketches.
+    If you're using an instance variable, say, @speed, to control 
+    the speed of your sketch. 
+    
+    has_slider :speed
+    
+    Will bring up a panel alongside with a slider that controls 
+    the speed. It can take a range of values as an optional parameter. 
+    Check out and run jwishy.rb for an example.
+  
+  * Multi-platform app export! Exporting your Ruby-Processing 
+    apps will now create executable apps for Mac/Windows/Linux.
+    
+  * Live coding support. Now you can do script/live path/to/sketch.rb 
+    to open up an interactive session with your sketch available
+    as $app.
+    
+  * Nick Sieger donated an additional sample.
+
+v0.8. Exporting Applications
+  * Ruby-Processing can now export Mac applications! Running 
+    script/application my_sketch.rb will create MySketch.app, 
+    complete with all of its data and libraries. If you have 
+    a .icns file inside of your data folder, it will become 
+    the app's icon.
+    
+  * Added a mathematical Fern sample. It's a port of Luis 
+    Correia's java original, with algorithms from Wikipedia.
+    
+  * Sketches now have a library_loaded? method, so that you can 
+    check if a library has been started successfully, and 
+    conditionally enable things. (Good for OpenGL.)
+    
+  * The Boids library is now about 40% faster. It also comes with
+    an example in library/boids/samples.
+    
+  * Specs have been started both for exporting and for Ruby-
+    Processing itself.
+
+v0.7. Flocking Boids and OpenGL Applets
+  * Thanks to MenTaLguY, once again, for work on the JRubyApplet, OpenGL 
+    is now a first-class citizen. If you're using OpenGL in your sketch, 
+    the applet exporter should just work. It has also been moved and 
+    renamed, so now you can use it like:
+    
+    script/applet my_sketch.rb
+  
+  * An app generator has been added for getting started. It'll give you 
+    a template for an empty Ruby-Processing sketch, with setup and draw
+    methods and all that. Usage:
+    
+    script/generate my_sketch 800 600
+    
+    Will create a file called my_sketch.rb, with a title of "My Sketch",
+    800 pixels wide and 600 pixels tall. Width and height are optional.
+    
+  * Ruby-Processing now includes its first pure-Ruby library, a port 
+    of Tom de Smedt's "Boids", for algorithmic flocking.
+
+v0.6. Generating Applets
+  * Now we're baking up some applet pie. The applet_tree script will 
+    take your Ruby-Processing sketch, export it as an applet, and 
+    generate an HTML page for you to post. It's way easier now than it 
+    would have been before. (thanks to MenTaLguY.) Use it like so:
+    
+    ./applet_tree my_sketch.rb
+    
+    But there are caveats: Applets don't work with native libraries, so 
+    no OpenGL. If you're requiring other files that aren't part of the 
+    standard Ruby distro, you'll need to include them as libraries, which 
+    means: Drop them in a folder inside of "library". Use
+    load_ruby_library("folder_name") or load_java_library() to load 'em.
+    These methods replace the previous load_library(). Ruby libs will 
+    load the .rb with the same name as the folder. Java libs will just 
+    load up all of the .jars in the folder.
+    
+    Demos — all of the standard samples are available as applets:
+    http://fiercefrontiers.com/applets/jwishy/
+    http://fiercefrontiers.com/applets/tree/
+    http://fiercefrontiers.com/applets/circle_collision/
+    http://fiercefrontiers.com/applets/reflection/
+    
+
+v0.5. With Native Libraries
+  * Ruby-Processing gets easy native library support. Now you can take 
+    Processing libraries, drop them in the library folder, and load them 
+    up like so (inside your sketch):
+    
+    load_library "opengl"
+    
+    It works by loading up all of the .jars in that folder, and setting
+    the java.library.path to that folder, so that the native extensions
+    can be found.
+    
+  * Full Screen OpenGL demo added, but you'll need to copy over the 
+    OpenGL library to use it.
+
+v0.4. Going Fullscreen
+  * Ruby-Processing goes fullscreen. Just pass :full_screen => true 
+    into the options when you’re starting up your app. Like so:
+
+    MyApp.new(:title => "MyApp", :full_screen => true)
+
+  * Because Processing has just so many methods, you can now search 
+    through them: find_method "method_name"
+
+v0.3. First Real Release
+  * Processing::App.current will give you a handle on the app. (Useful 
+    in jirb).
+  * samples/jwishy.rb has some new hooks for live coding.
+  * circle_collision and tree samples added (Joe Holt)

data/LICENSE

@@ -0,0 +1,37 @@
+Ruby-Processing is released under the MIT License. 
+You can do pretty much whatever you'd like with it.
+
+====================================================
+
+Copyright (c) 2008 omygawshkenas
+
+Permission is hereby granted, free of charge, 
+to any person obtaining a copy of this software 
+and associated documentation files (the "Software"), 
+to deal in the Software without restriction, 
+including without limitation the rights to use, 
+copy, modify, merge, publish, distribute, sublicense, 
+and/or sell copies of the Software, and to permit 
+persons to whom the Software is furnished to do so, 
+subject to the following conditions:
+
+The above copyright notice and this permission 
+notice shall be included in all copies or substantial 
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY 
+OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT 
+LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS 
+BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, 
+ARISING FROM, OUT OF OR IN CONNECTION WITH THE 
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+====================================================
+
+Ruby-Processing also distributes core components 
+of both JRuby and Processing, which are licensed 
+under the GNU Lesser General Public License.
+

data/README

@@ -0,0 +1,61 @@
+=
+   ____        _                 ____                              _             
+  |  _ \ _   _| |__  _   _      |  _ \ _ __ ___   ___ ___  ___ ___(_)_ __   __ _ 
+  | |_) | | | | '_ \| | | |_____| |_) | '__/ _ \ / __/ _ \/ __/ __| | '_ \ / _` |
+  |  _ <| |_| | |_) | |_| |_____|  __/| | | (_) | (_|  __/\__ \__ \ | | | | (_| |
+  |_| \_\\__,_|_.__/ \__, |     |_|   |_|  \___/ \___\___||___/___/_|_| |_|\__, |
+                     |___/                                                 |___/ 
+
+
+  Ruby-Processing is a Ruby wrapper for the Processing code art framework. It's
+  this thin little shim that squeezes between Processing and JRuby, passing 
+  along some neat goodies like:
+  
+  * Applet and Application exporting of your sketches. Hand them out to 
+    your party guests, ready-to-run.
+    
+  * Live Coding via JRuby's IRB. Loads in your sketch so you can futz with 
+    variables and remake methods on the fly.
+    
+  * A "Control Panel" library, so that you can easily create sliders, buttons,
+    checkboxes and drop-down menus, and hook them into your sketch's instance 
+    variables.
+    
+  * "Watch" mode, where Ruby-Processing keeps an eye on your sketch and reloads 
+    it from scratch every time you make a change. A pretty nice REPL-ish way
+    to work on your Processing sketches.
+    
+  If some quality time with Ruby is your idea of a pleasant afternoon, or you
+  harbor ambitions of entering the fast-paced and not altogether cutthroat world 
+  of Code Art, then Ruby-Processing is probably something you should try on for 
+  size. You can grab it as a gem:
+  
+  sudo gem install ruby-processing
+    
+    
+  ~ But Processing? ~
+  
+  Processing is an MIT-developed framework for making little code artifacts, 
+  animations, visualizations, and the like, developed originally by Ben Fry
+  and Casey Reas, supported by a small army of open-source contributors. 
+  Processing has become a sort of standard for visually-oriented programming,
+  strongly influencing the designs of Nodebox, Shoes, Arduino, and other kindred
+  projects. For more information, take a look at http://processing.org/
+  
+  
+  ~ What does it look like? How does it smell? ~
+  
+  Processing provides a tidy API, with a bunch of handy methods you can call 
+  from Ruby-Processing. Here's a smattering:
+  
+  alpha, arc, background, blend, blue, ellipse, frame_rate, hue, lerp, 
+  load_image, load_pixels, mouse_pressed, noise, rect, saturation, shape, 
+  smooth, text_align, translate, triangle...
+  
+  And so on, and so forth. See the full list here: 
+  http://www.processing.org/reference/index_ext.html
+  
+  ~ How can I learn more? ~
+
+  For full, up-to-date info, always check the wiki:
+  http://wiki.github.com/jashkenas/ruby-processing

data/bin/rp5

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.dirname(__FILE__) + "/../lib/ruby-processing")
+Processing::Runner.execute

data/lib/ruby-processing.rb

@@ -0,0 +1,27 @@
+# Ruby-Processing is for Code Art.
+# Send suggestions, ideas, and hate-mail to jashkenas [at] gmail.com
+# Also, send samples and libraries.
+
+unless defined? RP5_ROOT
+  $LOAD_PATH << File.expand_path(File.dirname(__FILE__))
+  RP5_ROOT = File.expand_path(File.dirname(__FILE__) + "/../")
+end
+
+require 'ruby-processing/helpers/string'
+
+# The top-level namespace, a home for all Ruby-Processing classes.
+module Processing
+  VERSION = [1,0,1]
+  
+  # Returns the current version of Ruby-Processing.
+  def self.version
+    VERSION.join('.')
+  end
+  
+  autoload :App,                  'ruby-processing/app'
+  autoload :Runner,               'ruby-processing/runner'
+  autoload :Creator,              'ruby-processing/exporters/creator'
+  autoload :BaseExporter,         'ruby-processing/exporters/base_exporter'
+  autoload :AppletExporter,       'ruby-processing/exporters/applet_exporter'
+  autoload :ApplicationExporter,  'ruby-processing/exporters/application_exporter'
+end

data/lib/ruby-processing/app.rb

@@ -0,0 +1,358 @@
+# This class is a thin wrapper around Processing's PApplet.
+# Most of the code here is for interfacing with Swing, 
+# web applets, going fullscreen and so on.
+
+require 'java'
+
+module Processing 
+
+  # Conditionally load core.jar
+  require "#{RP5_ROOT}/lib/core/core.jar" unless Object.const_defined?(:JRUBY_APPLET)  
+  include_package "processing.core"
+
+  # 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 
+  # mandatory methods, 'setup' and 'draw', both of which you
+  # 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.
+  class App < PApplet
+    include Math
+
+    include_class "javax.swing.JFrame"
+    
+    # Alias some methods for familiarity for Shoes coders.
+    attr_accessor :frame, :title
+    alias_method :oval, :ellipse
+    alias_method :stroke_width, :stroke_weight
+    alias_method :rgb, :color
+    alias_method :gray, :color
+
+    # Watch the definition of these methods, to make sure 
+    # that Processing is able to call them during events.
+    METHODS_TO_WATCH_FOR = { 
+      :mouse_pressed  => :mousePressed,
+      :mouse_dragged  => :mouseDragged,
+      :mouse_clicked  => :mouseClicked,
+      :mouse_moved    => :mouseMoved, 
+      :mouse_released => :mouseReleased,
+      :key_pressed    => :keyPressed,
+      :key_released   => :keyReleased,
+      :key_typed      => :keyTyped 
+    }
+
+
+    def self.method_added(method_name) #:nodoc:
+      if METHODS_TO_WATCH_FOR.keys.include?(method_name)
+        alias_method METHODS_TO_WATCH_FOR[method_name], method_name
+      end
+    end
+
+
+    # Class methods that we should make available in the instance.
+    [:map, :pow, :norm, :lerp, :second, :minute, :hour, :day, :month, :year, 
+     :sq, :constrain, :dist, :blend_color].each do |meth|
+      method = <<-EOS
+        def #{meth}(*args)
+          self.class.#{meth}(*args)
+        end
+      EOS
+      eval method
+    end
+    
+
+    def self.current=(app); @current_app = app; end
+    def self.current; @current_app; end   
+    
+
+    # Are we running inside an applet?
+    def self.online?
+      @online ||= Object.const_defined?(:JRUBY_APPLET)
+    end
+    def online?; self.class.online?; end
+
+
+    # Detect if a library has been loaded (for conditional loading)
+    @@loaded_libraries = Hash.new(false)
+    def self.library_loaded?(folder)
+      @@loaded_libraries[folder.to_sym]
+    end
+    def library_loaded?(folder); self.class.library_loaded?(folder); 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 self.load_libraries(*args)
+      args.each {|lib| load_ruby_library(lib) || load_java_library(lib) }
+    end
+    def self.load_library(*args); self.load_libraries(*args); end
+
+    # For pure ruby libraries.
+    # The library should have an initialization ruby file 
+    # of the same name as the library folder.
+    def self.load_ruby_library(dir)
+      dir = dir.to_sym
+      return true if @@loaded_libraries[dir]
+      return @@loaded_libraries[dir] = (require "library/#{dir}/#{dir}") if online?
+      local_path = "#{Dir.pwd}/library/#{dir}"
+      gem_path = "#{RP5_ROOT}/library/#{dir}"
+      path = File.exists?(local_path) ? local_path : gem_path
+      return false unless (File.exists?("#{path}/#{dir}.rb"))
+      return @@loaded_libraries[dir] = (require "#{path}/#{dir}")
+    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 self.load_java_library(dir)
+      dir = dir.to_sym
+      return true if @@loaded_libraries[dir]
+      return @@loaded_libraries[dir] = !!(JRUBY_APPLET.get_parameter("archive").match(%r(#{dir}))) if online?
+      local_path = "#{Dir.pwd}/library/#{dir}"
+      gem_path = "#{RP5_ROOT}/library/#{dir}"
+      path = File.exists?(local_path) ? local_path : gem_path
+      jars = Dir.glob("#{path}/**/*.jar")
+      return false if jars.empty?
+      jars.each {|jar| require jar }
+      # Here goes...
+      library_path = java.lang.System.getProperty("java.library.path")
+      new_library_path = [path, "#{path}/library", library_path].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
+      return @@loaded_libraries[dir] = true
+    end
+
+
+    def self.has_slider(*args) #:nodoc:
+      raise "has_slider has been replaced with a nicer control_panel library. Check it out."
+    end
+
+
+    # Used by the Processing::Watcher to completely remove all 
+    # traces of the current sketch, so that it can be loaded afresh.
+    def self.wipe_out_current_app!
+      app = Processing::App.current
+      return unless app
+      app_class_name = app.class.to_s.to_sym
+      app.close
+      Object.send(:remove_const, app_class_name)
+    end
+
+
+    # When you make a new sketch, you pass in (optionally), 
+    # a width, height, title, and whether or not you want to 
+    # run in full-screen. 
+    #
+    # This is a little different than Processing where height
+    # and width are declared inside the setup method instead.
+    def initialize(options = {})
+      super()
+      $app = App.current = self
+      set_sketch_path unless online?
+      make_accessible_to_the_browser
+      options = {
+        :width => 400, 
+        :height => 400, 
+        :title => "",
+        :full_screen => false
+      }.merge(options)
+      @width, @height, @title = options[:width], options[:height], options[:title]
+      @render_mode = P2D
+      determine_how_to_display options
+    end
+
+
+    # Provide a loggable string to represent this sketch.
+    def inspect
+      "#<Processing::App:#{self.class}:#{@title}>"
+    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 = self.java_class.declared_field('sketchPath')
+      field.set_value(Java.ruby_to_java(self), path || File.dirname(SKETCH_PATH))
+    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
+
+
+    # Specify what rendering Processing should use.
+    def render_mode(mode_const)
+      @render_mode = mode_const
+      size(@width, @height, @render_mode)
+    end
+
+
+    # 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
+
+
+    # Fix java conversion problems getting the last key
+    def key
+      field = java_class.declared_field 'key'
+      app = Java.ruby_to_java self
+      field.value app
+    end
+
+
+    # From ROP. Turns a color hash-string into hexadecimal, for Processing.
+    def hex(value)
+      value[1..-1].hex + 0xff000000
+    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
+
+
+    # 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
+    
+    
+    # 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
+    
+
+    # Cleanly close and shutter a running sketch.
+    def close
+      Processing::App.current = nil
+      control_panel.remove if respond_to?(:control_panel) && !online?
+      container = (@frame || JRUBY_APPLET)
+      container.remove(self)
+      self.destroy
+      container.dispose
+    end
+
+    
+    def quit
+      exit
+    end
+    
+    
+    private
+    
+    # Tests to see which display method should run.
+    def determine_how_to_display(options)
+      if online? # Then display it in an applet.
+        display_in_an_applet
+      elsif options[:full_screen] # Then display it fullscreen.
+        graphics_env = java.awt.GraphicsEnvironment.get_local_graphics_environment.get_default_screen_device
+        graphics_env.is_full_screen_supported ? display_full_screen(graphics_env) : display_in_a_window
+      else # Then display it in a window.
+        display_in_a_window
+      end
+    end
+    
+    
+    def display_full_screen(graphics_env)
+      @frame = java.awt.Frame.new
+      mode = graphics_env.display_mode
+      @width, @height = mode.get_width, mode.get_height
+      gc = graphics_env.get_default_configuration
+      @frame.set_undecorated true
+      @frame.set_background java.awt.Color.black
+      @frame.set_layout java.awt.BorderLayout.new
+      @frame.add(self, java.awt.BorderLayout::CENTER)
+      @frame.pack
+      graphics_env.set_full_screen_window @frame
+      @frame.set_location(0, 0)
+      @frame.show
+      self.init
+      self.request_focus
+    end
+
+
+    def display_in_a_window
+      @frame = JFrame.new(@title)
+      @frame.add(self)
+      @frame.setSize(@width, @height + 22)
+      @frame.setDefaultCloseOperation(JFrame::EXIT_ON_CLOSE)
+      @frame.setResizable(false)
+      @frame.show
+      self.init
+    end
+
+
+    def display_in_an_applet
+      JRUBY_APPLET.set_size(@width, @height)
+      JRUBY_APPLET.background_color = nil
+      JRUBY_APPLET.double_buffered = false
+      JRUBY_APPLET.add self
+      JRUBY_APPLET.validate
+      # Add the callbacks to peacefully expire.
+      JRUBY_APPLET.on_stop { self.stop }
+      JRUBY_APPLET.on_destroy { self.destroy }
+      self.init
+    end
+    
+    
+    # When the net library is included, we make the Ruby interpreter
+    # accessible to javascript as the 'ruby' variable. From javascript,
+    # you can call evalScriptlet() to run code against the sketch.
+    def make_accessible_to_the_browser
+      return unless library_loaded?('net') && online?
+      field = java.lang.Class.for_name("org.jruby.JRubyApplet").get_declared_field("runtime")
+      field.set_accessible true
+      ruby = field.get(JRUBY_APPLET)
+      window = Java::netscape.javascript.JSObject.get_window(JRUBY_APPLET)
+      window.set_member('ruby', ruby)
+    end
+
+  end
+end