ruby-processing 1.0.8 → 1.0.9

data/lib/ruby-processing/exporters/applet_exporter.rb

@@ -40,7 +40,10 @@ module Processing
       @necessary_files = [@main_file_path]
       @necessary_files += Dir["#{RP5_ROOT}/lib/{*,**}"]
       @necessary_files += @real_requires
-      @necessary_files << "#{@main_folder}/data" if File.exists?("#{@main_folder}/data")
+      NECESSARY_FOLDERS.each do |folder| 
+        resource_path = File.join(@main_folder, folder)
+        @necessary_files << resource_path if File.exists?(resource_path)
+      end
       @necessary_files += Dir["#{RP5_ROOT}/lib/templates/applet/{*,**}"]
       @necessary_files += Dir.glob("library/{#{@libraries.join(",")}}") unless @libraries.empty?
       @necessary_files.uniq!

data/lib/ruby-processing/exporters/application_exporter.rb

@@ -42,7 +42,10 @@ module Processing
       @necessary_files = [@main_file_path]
       @necessary_files += Dir["#{RP5_ROOT}/lib/{*,**}"]
       @necessary_files += @real_requires
-      @necessary_files << "#{@main_folder}/data" if File.exists?("#{@main_folder}/data")
+      NECESSARY_FOLDERS.each do |folder| 
+        resource_path = File.join(@main_folder, folder)
+        @necessary_files << resource_path if File.exists?(resource_path)
+      end
       @necessary_files.uniq!
       cp_r(@necessary_files, File.join(@dest, @prefix))
       cp_r(@libraries, File.join(@dest, @prefix, "library")) unless @libraries.empty?
@@ -66,6 +69,7 @@ module Processing
       move @dest + "/run.exe", "#{runnable}.exe"
       chmod 0755, runnable
       chmod 0755, "#{runnable}.exe"
+      chmod 0755, File.join(@dest, 'Contents', 'MacOS', 'JavaApplicationStub')
     end
     
     def symlink_library_into_place

data/lib/ruby-processing/exporters/base_exporter.rb

@@ -10,6 +10,7 @@ module Processing
     
     DEFAULT_DIMENSIONS = {'width' => '100', 'height' => '100'}
     DEFAULT_DESCRIPTION = ''
+    NECESSARY_FOLDERS = ['data', 'lib', 'vendor']
     
     # Returns the filepath, basename, and directory name of the sketch.
     def get_main_file(file)
@@ -42,7 +43,7 @@ module Processing
     
     # Searches the source for a title.
     def extract_title(source)
-      match = source.match(/#{@info[:class_name]}\.new.*?:title\s=>\s["'](.+)["']/m)
+      match = source.match(/#{@info[:class_name]}\.new.*?:title\s=>\s["'](.+?)["']/m)
       match ? match[1] : File.basename(@file, '.rb').titleize
     end
     
@@ -89,7 +90,7 @@ module Processing
       requirements = []
       partial_paths = []
       loop do
-        matchdata = code.match(/^.*\b(require|load)\b.*$/)
+        matchdata = code.match(/^.*[^::\.\w](require|load)\b.*$/)
         break unless matchdata
         line = matchdata[0].gsub('__FILE__', "'#{@main_file_path}'")
         line = line.gsub(/\b(require|load)\b/, 'partial_paths << ')

data/lib/ruby-processing/runner.rb

@@ -2,45 +2,45 @@ require 'ostruct'
 require 'fileutils'
 
 module Processing
-  
+
   # Utility class to handle the different commands that the 'rp5' command
   # offers. Able to run, watch, live, create, app, applet, and unpack
   class Runner
-    
+
     HELP_MESSAGE = <<-EOS
-      
+
   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
-    
+
   Examples:
     rp5 unpack samples
     rp5 run samples/jwishy.rb
     rp5 create some_new_sketch --bare 640 480
     rp5 watch some_new_sketch.rb
     rp5 applet some_new_sketch.rb
-    
+
   Everything Else:
-    http://wiki.github.com/jashkenas/ruby-processing    
-    
+    http://wiki.github.com/jashkenas/ruby-processing
+
       EOS
-    
+
     # Start running a ruby-processing sketch from the passed-in arguments
     def self.execute
       runner = new
       runner.parse_options(ARGV)
       runner.execute!
     end
-    
+
     # Dispatch central.
     def execute!
       case @options.action
-      when 'run'    then run(@options.path)
-      when 'watch'  then watch(@options.path)
+      when 'run'    then run(@options.path, @options.args)
+      when 'watch'  then watch(@options.path, @options.args)
+      when 'live'   then live(@options.path, @options.args)
       when 'create' then create(@options.path, @options.args, @options.bare)
-      when 'live'   then live(@options.path)
       when 'app'    then app(@options.path)
       when 'applet' then applet(@options.path)
       when 'unpack' then unpack(@options.path)
@@ -50,52 +50,53 @@ module Processing
         show_help
       end
     end
-    
+
     # Parse the command-line options. Keep it simple.
     def parse_options(args)
       @options = OpenStruct.new
       @options.bare   = !!args.delete('--bare')
+      @options.jruby  = !!args.delete('--jruby')
       @options.action = args[0]     || nil
       @options.path   = args[1]     || File.basename(Dir.pwd + '.rb')
       @options.args   = args[2..-1] || []
     end
-    
+
     # Create a fresh Ruby-Processing sketch, with the necessary
     # boilerplate filled out.
     def create(sketch, args, bare)
       Processing::Creator.new.create!(sketch, args, bare)
     end
-    
+
     # Just simply run a ruby-processing sketch.
-    def run(sketch)
+    def run(sketch, args)
       ensure_exists(sketch)
-      spin_up('run.rb', sketch)
+      spin_up('run.rb', sketch, args)
     end
-    
+
     # Run a sketch, keeping an eye on it's file, and reloading
     # whenever it changes.
-    def watch(sketch)
+    def watch(sketch, args)
       ensure_exists(sketch)
-      spin_up('watch.rb', sketch)
+      spin_up('watch.rb', sketch, args)
     end
-    
+
     # Run a sketch, opening its guts to IRB, letting you play with it.
-    def live(sketch)
+    def live(sketch, args)
       ensure_exists(sketch)
-      spin_up('live.rb', sketch)
+      spin_up('live.rb', sketch, args)
     end
-    
+
     # Generate a cross-platform application of a given Ruby-Processing sketch.
     def app(sketch)
       Processing::ApplicationExporter.new.export!(sketch)
     end
-    
+
     # Generate an applet and HTML page for a given sketch.
     def applet(sketch)
       Processing::AppletExporter.new.export!(sketch)
     end
-    
-    # Install the included samples to a given path, where you can run and 
+
+    # Install the included samples to a given path, where you can run and
     # alter them to your heart's content.
     def unpack(dir)
       require 'fileutils'
@@ -103,52 +104,59 @@ module Processing
       puts usage and return unless dir.match(/\A(samples|library)\Z/)
       FileUtils.cp_r("#{RP5_ROOT}/#{dir}", "#{Dir.pwd}/#{dir}")
     end
-    
+
     # Display the current version of Ruby-Processing.
     def show_version
-      puts "Ruby-Processing version #{Processing.version}"
+      puts "Ruby-Processing version #{Processing::VERSION}"
     end
-    
+
     # Show the standard help/usage message.
     def show_help
       puts HELP_MESSAGE
     end
-    
-    
+
+
     private
-    
-    # Trade in this Ruby instance for a JRuby instance, loading in a 
+
+    # Trade in this Ruby instance for a JRuby instance, loading in a
     # starter script and passing it some arguments.
-    def spin_up(starter_script, sketch)
+    # If --jruby is passed, use the installed version of jruby, instead of
+    # our vendored jarred one (useful for gems).
+    def spin_up(starter_script, sketch, args)
       runner = "#{RP5_ROOT}/lib/ruby-processing/runners/#{starter_script}"
       java_args = discover_java_args(sketch)
-      command = "java #{java_args} -cp \"#{jruby_complete}\" #{dock_icon} org.jruby.Main \"#{runner}\" #{sketch}"
-      exec(command)
+      command = @options.jruby ?
+                ['jruby', java_args, runner, sketch, args].flatten :
+                ['java', java_args, '-cp', jruby_complete, 'org.jruby.Main', runner, sketch, args].flatten
+      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://java.sun.com/j2se/1.4.2/docs/tooldocs/windows/java.html
     # 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"
-      File.exists?(arg_file) ? File.read(arg_file).gsub("\n", " ") : ''
+      args = dock_icon
+      args += File.read(arg_file).split(/\s+/) if File.exists?(arg_file)
+      args.map! {|arg| "-J#{arg}" }            if @options.jruby
+      args
     end
-    
+
     def ensure_exists(sketch)
       puts "Couldn't find: #{sketch}" and exit unless File.exists?(sketch)
     end
-    
+
     def jruby_complete
       File.join(RP5_ROOT, 'lib/core/jruby-complete.jar')
     end
-    
+
     # On the Mac, we can display a fat, shiny ruby in the Dock.
     def dock_icon
       mac = RUBY_PLATFORM.match(/darwin/i) || (RUBY_PLATFORM == 'java' && ENV_JAVA['os.name'].match(/mac/i))
-      mac ? "-Xdock:name=Ruby-Processing -Xdock:icon=#{RP5_ROOT}/lib/templates/application/Contents/Resources/sketch.icns" : ""
+      mac ? ["-Xdock:name=Ruby-Processing", "-Xdock:icon=#{RP5_ROOT}/lib/templates/application/Contents/Resources/sketch.icns"] : []
     end
-    
+
   end # class Runner
-  
+
 end # module Processing

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

@@ -1,5 +1,6 @@
 $LOAD_PATH << File.expand_path(File.dirname(__FILE__) + "/../../")
-SKETCH_ROOT = File.dirname(ARGV[0]) unless defined? SKETCH_ROOT
+SKETCH_PATH = ARGV.shift
+SKETCH_ROOT = File.dirname(SKETCH_PATH) unless defined? SKETCH_ROOT
 
 require 'ruby-processing'
 require 'ruby-processing/app'
@@ -7,8 +8,6 @@ require 'ruby-processing/app'
 
 module Processing
   
-  SKETCH_PATH = ARGV[0]
-  
   # For use with "bare" sketches that don't want to define a class or methods
   SKETCH_TEMPLATE = <<-EOS
     class Sketch < Processing::App
@@ -31,13 +30,13 @@ module Processing
     has_methods = !!source.match(/^[^#]*(def\s+setup|def\s+draw)/)
     
     if has_sketch
-      load Processing::SKETCH_PATH
+      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, Processing::SKETCH_PATH, 0
+      Object.class_eval code, SKETCH_PATH, 0
       Processing::App.sketch_class.new if !$app
     end
   end
@@ -48,7 +47,7 @@ module Processing
     if Processing.online?
       # Fuck the following lines. Fucking Java can go sit on broken glass.
       source = ''
-      url = java.net.URL.new(JRUBY_APPLET.get_code_base, Processing::SKETCH_PATH)
+      url = java.net.URL.new(JRUBY_APPLET.get_code_base, SKETCH_PATH)
       input = java.io.BufferedReader.new(java.io.InputStreamReader.new(url.open_stream))
       while line = input.read_line do
         source << (line + "\n") if line
@@ -56,7 +55,7 @@ module Processing
       input.close
     else
       # Ahhh, much better.
-      source = File.read(Processing::SKETCH_PATH)
+      source = File.read(SKETCH_PATH)
     end
     source
   end

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

@@ -3,9 +3,10 @@
 # or will start with your sketch.
 
 require "#{File.dirname(__FILE__)}/base.rb"
+Processing.load_and_run_sketch
+
+ARGV.clear # So that IRB doesn't try to load them as files.
 
 require 'irb'
-ARGV[0] = nil # To keep IRB from trying to run it multiple times.
 IRB.setup(__FILE__)
-Processing.load_and_run_sketch
-IRB.start()
+IRB.start

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

@@ -1,25 +1,25 @@
 require "#{File.dirname(__FILE__)}/base.rb"
 
-module Processing  
-  
-  # A sketch loader, observer, and reloader, to tighten 
+module Processing
+
+  # A sketch loader, observer, and reloader, to tighten
   # the feedback between code and effect.
   class Watcher
-    
+
     # Sic a new Processing::Watcher on the sketch
     def initialize
-      @file = Processing::SKETCH_PATH
+      @file = SKETCH_PATH
       @time = Time.now
       # Doesn't work well enough for now.
       # record_state_of_ruby
-      Processing.load_and_run_sketch unless $app
       start_watching
     end
-    
-    
+
+
     # 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
@@ -29,22 +29,28 @@ module Processing
             # Taking it out the reset until it can be made to work more reliably
             # rewind_to_recorded_state
             GC.start
-            begin
-              Processing.load_and_run_sketch
-            rescue StandardError, ScriptError
-              print "Error in your sketch: ", $!, "\n"
-            end
+            @runner = Thread.start { report_errors { Processing.load_and_run_sketch } }
           end
           sleep 0.33
         end
       end
       thread.join
     end
-    
-    
-    # Used to completely remove all traces of the current sketch, 
+
+    # Convenience function to report errors when loading and running a sketch,
+    # instead of having them eaten by the thread they are loaded in.
+    def report_errors
+      yield
+    rescue Exception => e
+      puts "Exception occured while running sketch #{File.basename SKETCH_PATH}:"
+      puts e.to_s
+      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
@@ -54,15 +60,15 @@ module Processing
       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)    
+      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, 
+    # 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
@@ -71,19 +77,19 @@ module Processing
       @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| 
+      new_globals.each do |g|
         begin
           eval("#{g} = nil") # There's no way to undef a global variable in Ruby
         rescue NameError => e
@@ -91,8 +97,8 @@ module Processing
         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) }
@@ -104,7 +110,7 @@ module Processing
       constants.each {|c| recursively_remove_constants(c, c.constants) if c }
       constant_names.each {|name| base.send(:remove_const, name.to_sym) if name }
     end
-    
+
   end
 end