ruby-processing 1.0.11 → 2.4.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 9e35013f3111ccdac477b271d45a0774a6dfd6cb
+  data.tar.gz: c0ba3dc3c1b5c87ded476f3bb189d363a0d160d4
+SHA512:
+  metadata.gz: ecdb759d819121d7e12b51e8cf718d5cbc9cb8ce1a5054ca1edee7360b3d798b08d3c6099c61f7a233bdd0e08f9dfffb4e7dd989324f7f4bbb38c06d86decd6d
+  data.tar.gz: fd8eff69ce65e76ba53c2225468e01f115659541edffa9ce80ed7c423764899fcb308811b7bd345894aac1b30ffdf0588b903fcdc47861aa29839ee543a5a46e

data/.gitignore

@@ -0,0 +1,11 @@
+syntax: glob
+.DS_Store
+*.sw*
+*.*~
+*.pdf
+*.gem
+*.tgz
+*.jar
+*.zip
+samples/processing_app/topics/file_io/output/*.png
+Gemfile.lock

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+        - 1.9.3
+        - jruby-19mode
+
+

data/.yardopts

@@ -0,0 +1,5 @@
+--markup markdown
+-
+CONTRIBUTING.md
+LICENSE.md
+README.md

data/CHANGELOG

@@ -1,3 +1,84 @@
+v2.4.2 First release to to return to rubygems since processing 1.0.11
+* Features a post-install download of jruby-complete (version 1.7.9)
+* Features use of jars from an installed version of vanilla processing,
+* on linux and windows use version 2.1.0 (later versions may also work).
+* For Mac, especially if you are using Mac "java" stick with version 2.0.3
+
+v2.4.1 Update gemspec to match modern expectations
+
+v2.4.0 Returning to rubygems distribution, by not including any jars
+* Use jars from an installed version of vanilla processing-2.0.3 (or version 2.1.0 linux and windows)
+* Require an installed jruby (with an optional jruby-complete-1.7.8 post
+* install)
+
+v2.3.1 Revert to processing-2.0.3 for MacOSX
+* Mac users may use Apple jvm java 6
+* Windows and Linux users need at least java 7 jre (java 8 does now work)
+
+v2.2.2 Update to JRuby-1.7.6
+* Merge vec.rb, quaternion.rb and arcball.rb into vecmath.rb, stricter path
+# requires ruby filename to match that of library
+
+v2.2.1 Replacing 'arcball' library with 'vecmath' library
+* Arcball functionality is retained (in vecmath library), Vec2D and Vec3D 
+* have been added to 'vecmath' library, they provide a pure ruby alternative 
+* to processings PVector class, and hence a more ruby like interface
+
+
+v2.2.0 Update to JRuby-1.7.5
+* Changed app.rb to only java_import used, core classes thus when mode JAVA2D
+* ie default mode do not java_import opengl classes, removed event classes
+* since we failed to address the directly
+
+v2.1.6 In anticipation of JRuby-1.7.5
+* Minor release to crystalize changes before JRuby-1.7.5
+* Rakefile tries to detect Windows OS & warn possibly missing 'wget'
+* Rubified and expanded Shiffmans advanced data examples
+
+v2.1.5 Update to processing-2.0.3
+* Minor changes to control_panel
+* Introducing file_chooser, deprecate select_input
+* Added display_width and display_height aliases
+
+v2.1.4 Improved build file
+* Build corrected to work on systems with directories containing spaces/etc
+* Control panel extra feature to allow setting of look and feel
+
+v2.1.3 Update to processing-2.0.2
+* Minor update to samples
+
+v2.1.2 Moved JRuby-Complete.jar (avoids classpath conflict)
+* Change to using external jruby as default, introduce --nojruby
+* flag to use provided jruby-complete
+* Tests revised to be more compatible with minitest ethos (capture_io)
+
+v2.1.1 Added Gemfile
+* Support bundler usage
+
+v2.1.0 gc-pruned ruby-processing-2.0
+ * Since BFG tool was used for archive pruning
+ * This repo is not compatible with forks of jashkenas prior to this release
+
+v2.0.1 First minor revision for ruby-processing-2.0
+  * Changes for application export on Windows and linux
+  * Added support for 'require_relative' on export
+
+v2.0.0 A major revision, now based on processing-2.0 and JRuby 1.7+
+  * Processing updated to processing-2.0.1 export to applet has disappeared, also P3D is 
+  * the new OPENGL (except Jogl2 instead of Jogl1.1) if you've got an old graphics card or even some new netbook 
+  * with onboard graphics you may have issues
+  * http://forum.processing.org/one/topic/processing-2-0-won-t-run-on-netbooks-and-older-cheaper-hardware. 
+  * Processing-2.0  has its own event system (replacing java.awt.event), ruby-processing sketches will normally 
+  * use this event system.
+  * JRuby upgraded to 1.7.4 (default is ruby 1.9 and 2.0 is possible with a switch)
+  * NB: bare sketches replace class wrapped sketches see samples...
+  * Samples have been extended to include vanilla processing library examples.
+  * References to the 'online' variable have been removed (deprecated in processing-2.0 slated for removal)
+  * test suite now uses MiniTest some old tests have been remove. Others that probably will fail anyway, are
+  * temporarily marked as skip.	
+  * Samples now rely on ruby 1.9 (almost 2.0) and processing-2.0 
+  * Where possible examples have been 'fixed' to run with new version (backward compability is not possible)
+
 v1.0.11 Fixing broken stuffs...
   * JRuby upgraded to 1.6.5
   * applet export fixed

data/CONTRIBUTING.md

@@ -0,0 +1,33 @@
+## Contributing
+In the spirit of [free software][free-sw], **everyone** is encouraged to help improve this project.
+
+Here are some ways *you* can contribute:
+
+* by reporting bugs
+* by suggesting/implementing new features ( _export to ruboto would be cool_ )
+* by writing or editing documentation ( _expert Windows users could help write install instructions_ )
+* by contributing examples ( _show your creativity, or translate someone elses masterpiece_ )
+* by refactoring examples to be more rubyfied
+* by closing [issues][]
+* by proselytizing ruby-processing, we need more champions
+* by supporting [Processing.org][], nothing to do with us but we rely on them
+* by figuring out if we could replace swing with javafx for control_panel etc
+
+## Submitting an Issue
+We use the [GitHub issue tracker][issues] to track bugs and features. Before
+submitting a bug report or feature request, check to make sure it hasn't
+already been submitted. When submitting a bug report, ideally include a [Gist][]
+that includes a stack trace and any details that may be necessary to reproduce
+the bug, including your gem version, Ruby version, and operating system.
+
+
+## Submitting a Pull Request
+1. [Fork the repository.][fork]
+2. [Submit a pull request.][pr]
+
+[free-sw]: http://www.fsf.org/licensing/essays/free-sw.html
+[issues]: https://github.com/rubygems/gems/issues
+[gist]: https://gist.github.com/
+[fork]: http://help.github.com/fork-a-repo/
+[pr]: http://help.github.com/send-pull-requests/
+[processing.org]: http://processing.org/foundation/

data/Gemfile

@@ -0,0 +1,6 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in ruby-processing.gemspec
+gemspec
+
+

data/{LICENSE → LICENSE.md}

@@ -1,7 +1,7 @@
 Ruby-Processing is released under the MIT License. 
 You can do pretty much whatever you'd like with it.
 
-====================================================
+___
 
 Copyright (c) 2008 omygawshkenas
 
@@ -29,9 +29,11 @@ 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.
+of both [JRuby][] and [Processing][] both of which are 
+licensed under the GNU lesser public license
 
+[jruby]: http://www.jruby.org/
+[processing]: http://www.processing.org/

data/README.md

@@ -0,0 +1,114 @@
+# Ruby-Processing
+
+Is a ruby wrapper around the [Processing][] code art framework, built using [JRuby][].
+
+[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...
+
+## Installation
+
+Ideally you should install [jruby](http://jruby.org/download), at the very least you will have at least ruby-1.9.3 installed.  You should [download][] and install vanilla [processing-2.0.3](https://processing.org/download/) (MacOSX) or [processing-2.1.0](https://processing.org/download/) (Windows, Linux) prior to installing this version of ruby-processing. You must also set the `PROCESSING_ROOT` in the .rp5rc yaml configuration file, the easiest way is by running the [SetProcessingRoot.pde](https://gist.github.com/monkstone/7438749) sketch in the processing ide. The vendored jruby-complete-1.7.9 is added by running `install_jruby_complete` post install (required for application export), see wiki.
+
+Then install ruby-processing (from rubygems-org) in the usual way
+
+`gem install ruby-processing` some systems eg Ubuntu my require `sudo` access
+
+To install jruby-complete use our built in tool (relies on `wget` to download [jruby-complete-1.7.9](http://jruby.org/download))
+
+`install_jruby_complete`
+
+If you haven't got `wget` just download jruby-complete-1.7.9 to the vendors folder (then run above tool)
+
+
+## Documentation
+
+See [Wiki][]
+
+See also [FAQs][], [Contributing][] and [Samples][]
+
+# Usage Example
+
+```bash
+rp5 run my_sketch.rb 
+```
+
+or if not using system jruby
+
+```bash
+rp5 --nojruby run my_sketch.rb
+```
+
+where a simple ``my_sketch.rb`` could look like this
+
+```ruby
+def setup
+  size 400, 400  
+  fill 255
+end
+
+def draw
+  background 0
+  ellipse mouse_x, mouse_y, 100, 100
+end
+```
+
+or a simple 3D sketch ``cube.rb``
+
+```ruby
+def setup
+  size 640, 360, P3D 
+  @xmag = 0
+  @ymag = 0
+  @new_xmag = 0
+  @new_ymag = 0 
+  fill 200, 50, 50
+end
+
+def draw    
+  background 100    
+  push_matrix    
+  translate width/2, height/2, -30    
+  @new_xmag = mouse_x.to_f / width * TWO_PI
+  @new_ymag = mouse_y.to_f / height * TWO_PI    
+  diff = @xmag - @new_xmag
+  @xmag -= diff / 4 if diff.abs > 0.01    
+  diff = @ymag - @new_ymag
+  @ymag -= diff / 4 if diff.abs > 0.01    
+  rotate_x(-@ymag) 
+  rotate_y(-@xmag)    
+  box 150, 150, 150        
+  pop_matrix        
+end
+
+```
+
+## Supported Ruby Version
+
+This library has been tested with the following ruby implementations
+
+* Ruby 1.9.3
+* Ruby 2.0.0
+* [JRuby][] preferred (required to use rubygems in sketches)
+
+[License][]
+
+[license]:LICENSE.md
+[contributing]:CONTRIBUTING.md
+[jruby]:http://www.jruby.org/
+[processing]: http://www.processing.org/
+[download]:https://processing.org/download/
+[samples]:https://github.com/jashkenas/ruby-processing/tree/master/samples/
+[wiki]:http://github.com/jashkenas/ruby-processing/wikis/
+[FAQs]:http://github.com/jashkenas/ruby-processing/wikis/FAQs/
+[release]:https://github.com/jashkenas/ruby-processing/releases/
+
+## What's new
+
+New capabilities since processing-2.0 include ability to use OPENGL VBO (PShape) and GLSL shaders (PShader), to keep abreast of latest shader developments for processing check out the [codeanticode blog](http://codeanticode.wordpress.com/2013/06/04/processing-2-0-is-out-processing-2-0-is-in/). Some worked examples using new feature are included in the samples. The update to the latest jruby is also significant as the default is to run with ruby-1.9 support, and there have been many performance improvements. Some performance improvements will not be available on the Mac as they require at least java-7+, and there is even more to come with java-8+ (adventurous Mac users can read more about [Oracle java here](http://www.java.com/en/download/faq/java_mac.xml) ). More than 330 worked examples are included in the [Samples][], many of which are rubified version of the examples included with vanilla processing, and or the contributed libraries, additions are welcome.
+
+
+

data/Rakefile

@@ -0,0 +1,37 @@
+
+desc 'build and test'    
+task :default => [:build_and_test]
+
+task :build_and_test do
+  Rake::Task["build"].execute
+  Rake::Task["test"].execute
+end
+
+desc 'Build and install gem'
+task :install => :build do
+  sh "gem install #{Dir.glob('*.gem').join(' ')} --no-ri --no-rdoc"
+end
+
+desc 'Uninstall gem'
+task :uninstall do
+  sh "gem uninstall -x ruby-processing"	
+end
+
+desc 'Install jruby-complete'
+task :install_jruby_complete do
+  begin
+    sh "cd vendors && rake"
+  rescue
+    warn("WARNING: you may not have wget installed")	    
+  end
+end
+
+desc 'Build gem'
+task :build do
+  sh "gem build ruby-processing.gemspec"
+end
+
+desc 'Test'
+task :test do
+  ruby "test/rp5_test.rb"	
+end

data/bin/install_jruby_complete

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+
+file = __FILE__
+if test(?l,file)
+  require "pathname"
+  file = Pathname.new(file).realpath
+end
+
+begin
+  system "cd #{File.expand_path(File.dirname(file) +"/../vendors")} && rake"
+rescue
+  warn("WARNING: you may not have wget installed, you could just copy jruby complete to vendors folder instead of installing wget")	
+end

data/lib/ruby-processing.rb

@@ -9,21 +9,15 @@ end
 
 SKETCH_ROOT = Dir.pwd unless defined? SKETCH_ROOT
 
+require 'ruby-processing/version'
 require 'ruby-processing/helpers/string'
 require 'ruby-processing/helpers/numeric'
 
 # The top-level namespace, a home for all Ruby-Processing classes.
 module Processing
-  VERSION = "1.0.11" unless defined? Processing::VERSION
 
-  # Are we online -- inside an applet?
-  def self.online?
-    @online ||= defined?(JRUBY_APPLET)
-  end
-
-  # Are we embedded -- inside the Processing IDE?
-  def self.embedded?
-    @embedded ||= defined?(RP5_EMBEDDED)
+  def self.exported?
+    @exported ||= ENV['EXPORTED'].eql?('true')	  
   end
 
   # Autoload a number of constants that we may end up using.
@@ -32,6 +26,5 @@ module Processing
   autoload :Watcher,              'ruby-processing/runners/watch'
   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

@@ -1,23 +1,22 @@
+# version without embedded or online
 # 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'
-require 'ruby-processing/config'
 require 'ruby-processing/helper_methods'
 require 'ruby-processing/library_loader'
+require 'ruby-processing/config'
 
-# Conditionally load core.jar
-require "#{RP5_ROOT}/lib/core/core.jar" unless Processing.online? || Processing.embedded?
+Dir["#{Processing::CONFIG["PROCESSING_ROOT"]}/core/library/\*.jar"].each { |jar| require jar }
 
-# Include some processing classes that we'd like to use:
-%w(PShape PImage PGraphics PFont PVector).each do |klass|
-  import "processing.core.#{klass}"
+# 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}"
 end
 
 module Processing
-  import "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
@@ -28,63 +27,63 @@ module Processing
   class App < PApplet
     include Math
     include HelperMethods
-
+    
     # 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
-
-
+    
+    
     # 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
+        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.keys.include?(method_name)
         alias_method methods_to_alias[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, :degrees, :radians, :mag, :println,
-     :hex, :min, :max, :abs, :binary, :ceil, :nf, :nfc, :nfp, :nfs,
-     :norm, :round, :trim, :unbinary, :unhex ].each do |meth|
+    :sq, :constrain, :dist, :blend_color, :degrees, :radians, :mag, :println,
+    :hex, :min, :max, :abs, :binary, :ceil, :nf, :nfc, :nfp, :nfs,
+    :norm, :round, :trim, :unbinary, :unhex ].each do |meth|
       method = <<-EOS
-        def #{meth}(*args)
-          self.class.#{meth}(*args)
-        end
+      def #{meth}(*args)
+      self.class.#{meth}(*args)
+      end
       EOS
       eval method
     end
-
+    
     # Handy getters and setters on the class go here:
     def self.sketch_class;  @sketch_class;        end
-    @@full_screen = false
+      @@full_screen = false
     def self.full_screen;   @@full_screen = true; end
     def full_screen?;       @@full_screen;        end
-
-
+      
+      
     # Keep track of what inherits from the Processing::App, because we're going
     # to want to instantiate one.
     def self.inherited(subclass)
       super(subclass)
       @sketch_class = subclass
     end
-
+    
     def self.has_slider(*args) #:nodoc:
       raise "has_slider has been replaced with a nicer control_panel library. Check it out."
     end
@@ -95,24 +94,24 @@ module Processing
         @@library_loader.load_library(*args)
       end
       alias :load_library :load_libraries 
-
+      
       def library_loaded?(library_name)
         @@library_loader.library_loaded?(library_name)
       end
-
+      
       def load_ruby_library(*args)
         @@library_loader.load_ruby_library(*args)
       end
-
+      
       def load_java_library(*args)
         @@library_loader.load_java_library(*args)
       end
     end
-
+    
     def library_loaded?(library_name)
       self.class.library_loaded?(library_name)
     end
-
+    
     # When you make a new sketch, you pass in (optionally),
     # a width, height, x, y, title, and whether or not you want to
     # run in full-screen.
@@ -123,119 +122,75 @@ module Processing
       super()
       $app = self
       proxy_java_fields
-      set_sketch_path unless Processing.online?
+      set_sketch_path #unless Processing.online?
       mix_proxy_into_inner_classes
-      @started = false
-     
-      unless Processing.online?
-        java.lang.Thread.default_uncaught_exception_handler = proc do |thread, exception|
-          puts(exception.class.to_s)
-          puts(exception.message)
-          puts(exception.backtrace.collect { |trace| "\t" + trace })
-          close
-        end
+      #@started = false
+      
+      java.lang.Thread.default_uncaught_exception_handler = proc do |thread, exception|
+        puts(exception.class.to_s)
+        puts(exception.message)
+        puts(exception.backtrace.collect { |trace| "\t" + trace })
+        close        
       end
-
+      
       # for the list of all available args, see 
-      # http://processing.googlecode.com/svn/trunk/processing/build/javadoc/core/processing/core/PApplet.html#runSketch%28java.lang.String[],%20processing.core.PApplet%29
-      args = []
+      # http://processing.org/reference/
 
+      args = []
+      
       @width, @height = options[:width], options[:height]
-
+      
       if @@full_screen || options[:full_screen] 
         @@full_screen = true
         args << "--present"
-      end
-
+      end      
       @render_mode  ||= JAVA2D
-
-      if Processing.online?
-        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 }
-        init
-      else
         x = options[:x] || 0
         y = options[:y] || 0
-        args << "--location=#{x},#{y}"
-
-        title = options[:title] || File.basename(SKETCH_PATH).sub(/(\.rb|\.pde)$/, '').titleize
+        args << "--location=#{x}, #{y}"
+        
+        title = options[:title] || File.basename(SKETCH_PATH).sub(/(\.rb)$/, '').titleize
         args << title
         PApplet.run_sketch(args, self)
-      end
-    end
-
-    def started?
-      @started
+      #end
     end
 
-    def hint(*args)
-      begin
-        super(*args)
-      rescue Exception => e
-        raise e.cause
+    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}"
+        end
       end
-    end
-
+      super(*args)
+    end 
+    
     # Make sure we set the size if we set it before we start the animation thread.
     def start
       self.size(@width, @height) if @width && @height
       super()
     end
-
+    
     # Provide a loggable string to represent this sketch.
     def inspect
       "#<Processing::App:#{self.class}:#{@title}>"
     end
-
-
-    # We override size to support setting full_screen and to keep our
-    # internal @width and @height in line.
-    def size(*args)
-      args[0], args[1] = screenWidth, screenHeight if @@full_screen && !args.empty?
-      w, h, mode       = *args
-      @width           = w     || @width
-      @height          = h     || @height
-      @render_mode     = mode  || @render_mode
-      @started = true
-      super(*args)
-    rescue Exception => e
-      raise e.cause
-    end
-
-    def handleDraw()
-      super
-    rescue Exception => exception
-      puts(exception.message)
-      puts(exception.backtrace.collect { |trace| "\t" + trace })
-      close
-    end
-
-    # Specify what rendering Processing should use, without needing to pass size.
-    def render_mode(mode_const)
-      @render_mode = mode_const
-      size(@width, @height, @render_mode)
-    end
-
+   
+    
     # Cleanly close and shutter a running sketch.
     def close
-      #$app = nil
-      if Processing.online?
-        JRUBY_APPLET.remove(self)
-      else
         control_panel.remove if respond_to?(:control_panel)
         self.dispose
         self.frame.dispose
-      end
     end
-
-
+    
+    
     private 
-
+    
     # Mix the Processing::Proxy into any inner classes defined for the
     # sketch, attempting to mimic the behavior of Java's inner classes.
     def mix_proxy_into_inner_classes
@@ -247,16 +202,16 @@ module Processing
         const.class_eval 'include Processing::Proxy'
       end
     end
-
+    
   end # Processing::App
-
-
+  
+  
   # This module will get automatically mixed in to any inner class of
   # a Processing::App, in order to mimic Java's inner classes, which have
   # 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.
     # Nothing camelCased, nothing __internal__, just the Processing API.
     def self.desired_method_names(inner_class)
@@ -266,25 +221,25 @@ module Processing
       methods = Processing::App.public_instance_methods
       methods.reject {|m| unwanted.include?(m) || bad_method.match(m) || inner_class.method_defined?(m) }
     end
-
-
+    
+    
     # Proxy methods through to the sketch.
     def self.proxy_methods(inner_class)
       code = desired_method_names(inner_class).inject('') do |code, method|
         code << <<-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   #     $app.send(:rect, *args, &block)
+        else                                      #   else
+        $app.#{method} *args                    #     $app.rect *args
+        end                                       #   end
+        end                                         # end
         EOS
       end
       inner_class.class_eval(code)
     end
-
-
+    
+    
     # Proxy the sketch's constants on to the inner classes.
     def self.proxy_constants(inner_class)
       Processing::App.constants.each do |name|
@@ -292,14 +247,14 @@ module Processing
         inner_class.const_set(name, Processing::App.const_get(name))
       end
     end
-
-
+    
+    
     # Don't do all of the work unless we have an inner class that needs it.
     def self.included(inner_class)
       proxy_methods(inner_class)
       proxy_constants(inner_class)
     end
-
+    
   end # Processing::Proxy
-
+  
 end # Processing