jruby_art 0.2.6.pre → 0.3.0.pre

data/lib/jruby_art/helper_methods.rb

@@ -1,5 +1,6 @@
+# processing module wrapper
 module Processing
-  # Useful methods, not otherwise available	
+  # Provides some convenience methods
   module HelperMethods
     # processings epsilon may not be defined yet
     EPSILON ||= 1.0e-04
@@ -60,7 +61,7 @@ module Processing
     # function
     # @param [float] value input
     # @param [range] start1, stop1
-    # @param [range] start1, stop2
+    # @param [range] start2, stop2
     # @return [float] mapped value
     def map(value, start1, stop1, start2, stop2)
       start2 + (stop2 - start2) * ((value - start1).to_f / (stop1 - start1))
@@ -73,6 +74,23 @@ module Processing
         ((val - r_in.begin).to_f / (r_in.end - r_in.begin))
     end
 
+    # Explicitly provides 'processing.org' map instance method, where
+    # value is mapped from range 1 to range 2 where values are clamped to
+    # range 2.
+    # @param val input
+    # @param [r_in] start1, stop1
+    # @param [r_out] start2, stop2
+    # @return mapped value
+    def constrained_map(val, r_in, r_out)
+      unless r_in.include? val
+        return r_out.begin if (val < r_in.begin && r_in.begin < r_in.end) ||
+                              (val > r_in.begin && r_in.begin > r_in.end)
+        return r_out.end
+      end
+      r_out.begin + (r_out.end - r_out.begin) *
+        ((val - r_in.begin).to_f / (r_in.end - r_in.begin))
+    end
+
     # explicitly provide 'processing.org' norm instance method
     def norm(value, start, stop)
       (value - start).to_f / (stop - start)
@@ -101,25 +119,11 @@ module Processing
     def dist(*args)
       len = args.length
       if len == 4
-        dx = args[0] - args[2]
-        dy = args[1] - args[3]
-        return 0 if dx.abs < EPSILON && dy.abs < EPSILON
-        return Math.hypot(dx, dy)
-      end
-      fail ArgumentError, 'takes 4 parameters'
-    end
-
-    # dist_squared only makes sense with 3D distance
-    def dist_squared(*args)
-      len = args.length
-      if len == 6
-        dx = args[0] - args[3]
-        dy = args[1] - args[4]
-        dz = args[2] - args[5]
-        return 0 if dx.abs < EPSILON && dy.abs < EPSILON && dz.abs < EPSILON
-        return dx * dx + dy * dy + dz * dz
+        return dist2d(*args)
+      elsif len == 6
+        return dist3d(*args)
       end
-      fail ArgumentError, 'takes 6 parameters'
+      fail ArgumentError, 'takes 4 or 6 parameters'
     end
 
     # explicitly provide 'processing.org' constrain instance method
@@ -148,13 +152,6 @@ module Processing
       @declared_fields = Hash[fields.zip(methods)]
     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(spath = nil)
-      field = @declared_fields['sketchPath']
-      field.set_value(java_self, spath || SKETCH_ROOT)
-    end
-
     # Fix java conversion problems getting the last key
     # If it's ASCII, return the character, otherwise the integer
     def key
@@ -187,10 +184,6 @@ module Processing
 
     define_method(:key_code) { keyCode }
 
-    define_method(:display_height) { displayHeight }
-
-    define_method(:display_width) { displayWidth }
-
     # Ensure that load_strings returns a real Ruby array
     def load_strings(file_or_url)
       loadStrings(file_or_url).to_a
@@ -217,5 +210,22 @@ module Processing
     def key_pressed?
       @declared_fields['keyPressed'].value(java_self)
     end
+
+    private
+
+    def dist2d(*args)
+      dx = args[0] - args[2]
+      dy = args[1] - args[3]
+      return 0 if dx.abs < EPSILON && dy.abs < EPSILON
+      Math.hypot(dx, dy)
+    end
+
+    def dist3d(*args)
+      dx = args[0] - args[3]
+      dy = args[1] - args[4]
+      dz = args[2] - args[5]
+      return 0 if dx.abs < EPSILON && dy.abs < EPSILON && dz.abs < EPSILON
+      Math.sqrt(dx * dx + dy * dy + dz * dz)
+    end
   end
 end

data/lib/jruby_art/helpers/camel_string.rb

@@ -10,7 +10,8 @@ class CamelString
 
   def camelize(first_letter_in_uppercase = true)
     if first_letter_in_uppercase
-      @string.gsub(/\/(.?)/) { '::' + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+      @string.gsub(%r{/(.?)}) { '::' + Regexp.last_match[1].upcase }
+        .gsub(/(^|_)(.)/) { Regexp.last_match[2].upcase }
     else
       @string[0] + camelize[1..-1]
     end

data/lib/jruby_art/helpers/numeric.rb

@@ -1,5 +1,4 @@
-# extends Numeric class to provide degrees and radians convenience methods
-class Numeric  
+class Numeric #:nodoc:
   def degrees
     self * 180 / Math::PI
   end

data/lib/jruby_art/helpers/range.rb

@@ -1,11 +1,7 @@
+# Extend Range class to include clip (used to implement processing constrain)
 class Range #:nodoc:
   def clip(n)
-    if cover?(n)
-      n
-    elsif n < min
-      min
-    else
-      max
-    end
+    return n if cover?(n)
+    (n < min) ? min : max
   end
 end

data/lib/jruby_art/helpers/string_extra.rb

@@ -16,7 +16,7 @@ class StringExtra
       .downcase
       .gsub(/_id$/, '')
       .gsub(/_/, ' ').capitalize
-      .gsub(/\b([a-z])/) { $1.capitalize }
+      .gsub(/\b([a-z])/) { Regexp.last_match[1].capitalize }
   end
 
   def humanize

data/lib/jruby_art/library_loader.rb

@@ -1,104 +1,135 @@
-# The LibraryLoader class adds some logic for loading library jars/ruby libraries
-class LibraryLoader
-  require_relative 'config'
-  attr_reader :installed, :libraries_path, :loaded_libraries, :local
-  
-  def initialize
-    @libraries_path = Processing::RP_CONFIG.fetch('LIBRARIES_PATH', "#{ENV['HOME']}/.jruby_art/libraries")
-    @loaded_libraries = []
-    sketch_root = defined?(SKETCH_ROOT).nil? ? Dir.pwd : SKETCH_ROOT
-    @local = File.absolute_path("#{sketch_root}/library/")
-    @installed = File.absolute_path("#{K9_ROOT}/library/")
-  end
-  
-  # Load a list of Java libraries or ruby libraries
-  # Usage: load_libraries :boids, :control_panel, :video
-  #
-  # If a library is put into a 'library' folder next to the sketch it will
-  # be used instead of the library that ships with JRubyArt.
-  def load_libraries(*args)
-    args.each do |arg|
-      next if loaded_libraries.include? arg
-      local_ruby_lib(arg)
-      local_java_lib(arg)
-      installed_ruby_lib(arg)
-      installed_java_lib(arg)
+# Then processing wrapper module
+module Processing
+
+  # Encapsulate library loader functionality as a class
+  class LibraryLoader
+    attr_reader :sketchbook_library_path
+
+    def initialize
+      @sketchbook_library_path = File.join(find_sketchbook_path, 'libraries')
+      @loaded_libraries = Hash.new(false)
     end
-  end
-  
-  def local_java_lib(arg)
-    java_lib(local, arg)
-  end
-  
-  def installed_java_lib(arg)
-    java_lib(libraries_path, arg)
-  end
-  
-  def installed_ruby_lib(arg)
-    ruby_file = File.join(installed, format('%s/%s.rb', arg, arg))
-    return unless FileTest.exist?(ruby_file)
-    require ruby_file
-    loaded_libraries << arg
-  end
-  
-  def local_ruby_lib(arg)
-    ruby_file = File.join(local, format('%s.rb', arg))
-    return unless FileTest.exist? ruby_file
-    require ruby_file
-    loaded_libraries << arg
-  end
-  
-  # HACK: For pure java libraries, such as the ones that are available
-  # on this page: http://processing.org/reference/libraries/index.html
-  # that include native code, we mess with the 'Java ClassLoader', so that
-  # you don't have to futz with your PATH. But it's probably bad juju.
-  def java_lib(path, library_name)
-    library_name = library_name.to_sym
-    jars = get_library_paths(path, library_name)
-    jpath = format("%s/%s/library", path, library_name.to_s )
-    return false if jars.empty?
-    jars.each { |jar| require jar }
-    platform_specific_library_paths = get_platform_specific_library_paths(jpath)
-    platform_specific_library_paths = platform_specific_library_paths.select do |ppath|
-      test(?d, ppath) && !Dir.glob(File.join(ppath, '*.{so,dll,jnilib}')).empty?
+
+    # Detect if a library has been loaded (for conditional loading)
+    def library_loaded?(library_name)
+      @loaded_libraries[library_name.to_sym]
     end
-    unless 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)
+
+    # 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)
+      message = 'no such file to load -- %s'
+      args.each do |lib|
+        loaded = load_ruby_library(lib) || load_java_library(lib)
+        fail(LoadError.new, format(message, lib)) unless loaded
       end
     end
-    loaded_libraries << library_name
-  end
-  
-  def platform
-    match = %w(mac linux windows).find do |os|
-      java.lang.System.getProperty('os.name').downcase.index(os)
+    alias_method :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.include?(library_name)
+      path = get_library_paths(library_name, 'rb').first
+      return false unless path
+      @loaded_libraries[library_name] = (require path)
     end
-    return 'other' unless match
-    return match unless match =~ /mac/
-    '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')
-      bits = '32'
-    elsif java.lang.System.getProperty('sun.arch.data.model') == '64' ||
-      java.lang.System.getProperty('java.vm.name').index('64')
-      bits = '64' unless platform =~ /macosx/
+
+    # HACK: For pure java libraries, such as the ones that are available
+    # on this page: http://processing.org/reference/libraries/index.html
+    # that include native code, we mess with 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.include?(library_name)
+      jpath = get_library_directory_path(library_name, 'jar')
+      jars = get_library_paths(library_name, 'jar')
+      return false if jars.empty?
+      jars.each { |jar| require jar }
+      platform_specific_library_paths = get_platform_specific_library_paths(jpath)
+      platform_specific_library_paths = platform_specific_library_paths.select do |ppath|
+        FileTest.directory?(ppath) && !Dir.glob(File.join(ppath, '*.{so,dll,jnilib}')).empty?
+      end
+      unless 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
+      @loaded_libraries[library_name] = true
+    end
+
+    def platform
+      match = %w(mac linux windows).find do |os|
+        java.lang.System.getProperty('os.name').downcase.index(os)
+      end
+      return 'other' unless match
+      return match unless match =~ /mac/
+      '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')
+        bits = '32'
+      elsif java.lang.System.getProperty('sun.arch.data.model') == '64' ||
+        java.lang.System.getProperty('java.vm.name').index('64')
+        bits = '64' unless platform =~ /macosx/
+      end
+      [platform, platform + bits].map { |p| File.join(basename, p) }
+    end
+
+    def get_library_paths(library_name, extension = nil)
+      dir = get_library_directory_path(library_name, extension)
+      Dir.glob("#{dir}/*.{rb,jar}")
+    end
+
+    protected
+
+    def get_library_directory_path(library_name, extension = nil)
+      extensions = extension ? [extension] : %w(jar rb)
+      extensions.each do |ext|
+        ["#{SKETCH_ROOT}/library/#{library_name}",
+        "#{Processing::RP_CONFIG['PROCESSING_ROOT']}/modes/java/libraries/#{library_name}/library",
+        "#{RP5_ROOT}/library/#{library_name}/library",
+        "#{RP5_ROOT}/library/#{library_name}",
+        "#{@sketchbook_library_path}/#{library_name}/library"
+        ].each do |jpath|
+          if File.exist?(jpath) && !Dir.glob(format('%s/*.%s', jpath, ext)).empty?
+            return jpath
+          end
+        end
+      end
+      nil
+    end
+
+    def find_sketchbook_path
+      preferences_paths = []
+      sketchbook_paths = []
+      sketchbook_path = Processing::RP_CONFIG.fetch('sketchbook_path', false)
+      return sketchbook_path if sketchbook_path
+      ["'Application Data/Processing'", 'AppData/Roaming/Processing',
+       'Library/Processing', 'Documents/Processing',
+       '.processing', 'sketchbook'].each do |prefix|
+        spath = format('%s/%s', ENV['HOME'], prefix)
+        pref_path = format('%s/preferences.txt', spath)
+        preferences_paths << pref_path if FileTest.file?(pref_path)
+        sketchbook_paths << spath if FileTest.directory?(spath)
+      end
+      return sketchbook_paths.first if preferences_paths.empty?
+      lines = IO.readlines(preferences_paths.first)
+      matchedline = lines.grep(/^sketchbook/).first
+      matchedline[/=(.+)/].gsub('=', '')
     end
-    [platform, platform + bits].map { |p| File.join(basename, p) }
-  end
-  
-  def get_library_paths(path, library_name)
-    lib = File.join(path, library_name.to_s)
-    jar_files = File.join(lib, '**', '*.jar')
-    Dir.glob(jar_files)
   end
 end

data/lib/jruby_art/runner.rb

@@ -4,52 +4,66 @@ require 'rbconfig'
 require_relative '../jruby_art/config'
 require_relative '../jruby_art/version'
 
-
+# processing wrapper module
 module Processing
-  
-  # Utility class to handle the different commands that the 'rp5' command
+  # Utility class to handle the different commands that the 'k9' command
   # offers. Able to run, watch, live, create, app, and unpack
   class Runner
-    HELP_MESSAGE = <<-EOS
-    JRubyArt Version: #{JRubyArt::VERSION}
-    
-    JRubyArt is a little shim between Processing and JRuby that helps
+    HELP_MESSAGE ||= <<-EOS
+    Version: #{JRubyArt::VERSION}
+
+    Ruby-Processing is a little shim between Processing and JRuby that helps
     you create sketches of code art.
-    
+
     Usage:
-    k9 create some_new_sketch 640 480
-    jruby some_new_sketch.rb
-    
-    k9 run sketch.rb
-   
+    k9 [choice] sketch
+
+    choice:-
+    run:              run sketch once
+    watch:            watch for changes on the file and relaunch it on the fly
+    create [width height][mode][flag]: create a new sketch.
+    setup:            check setup, install jruby-complete, unpack samples
+
+    Common options:
+    --nojruby:  use jruby-complete in place of an installed version of jruby
+    (Set [JRUBY: 'false'] in .k9rc to make using jruby-complete default)
+
+    Examples:
+    k9 setup unpack_samples
+    k9 run rp_samples/samples/contributed/jwishy.rb
+    k9 create some_new_sketch 640 480 p3d (P3D mode example)
+    k9 create some_new_sketch 640 480 --wrap (a class wrapped default sketch)
+    k9 watch some_new_sketch.rb
+
+    Everything Else:
+    http://wiki.github.com/monkstone/jruby_art-3.0
+
     EOS
-    
+
     WIN_PATTERNS = [
-                      /bccwin/i,
-                      /cygwin/i,
-                      /djgpp/i,
-                      /mingw/i,
-                      /mswin/i,
-                      /wince/i
+      /bccwin/i,
+      /cygwin/i,
+      /djgpp/i,
+      /ming/i,
+      /mswin/i,
+      /wince/i
     ]
-    
+
     attr_reader :os
-    
-    # Start running a ruby-processing sketch from the passed-in arguments
+
+    # Start running a jruby_art 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, @options.args)
-      # when 'watch'  then watch(@options.path, @options.args)
-      when 'wrap'   then wrap(@options.path, @options.args)
+      when 'watch'  then watch(@options.path, @options.args)
       when 'create' then create(@options.path, @options.args)
-      # when 'app'    then app(@options.path)
       when 'setup'  then setup(@options.path)
       when /-v/     then show_version
       when /-h/     then show_help
@@ -57,66 +71,197 @@ module Processing
         show_help
       end
     end
-    
+
     # Parse the command-line options. Keep it simple.
     def parse_options(args)
       @options = OpenStruct.new
       @options.wrap = !args.delete('--wrap').nil?
+      @options.inner = !args.delete('--inner').nil?
+      @options.jruby = !args.delete('--jruby').nil?
+      @options.nojruby = !args.delete('--nojruby').nil?
       @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
+
+    # Create a fresh JRubyArt sketch, with the necessary
     # boilerplate filled out.
     def create(sketch, args)
-      require_relative 'creator'
-      Processing::ClassSketch.new.create!(sketch, args)
+      require_relative '../jruby_art/creators/creator'
+      return Processing::Inner.new.create!(sketch, args) if @options.inner
+      return Processing::ClassSketch.new.create!(sketch, args) if @options.wrap
+      Processing::BasicSketch.new.create!(sketch, args)
     end
-    
-    def wrap(sketch, args)
-      require_relative 'writer'
-      writer = Processing::Writer.new
-      writer.read(sketch)
-      writer.write
-    end
-  
+
+    # Just simply run a JRubyArt sketch.
     def run(sketch, args)
-      command = ['java', '-jar', jruby_complete, parse, sketch, args].flatten
-      exec(*command)
-    end
-    
-    def jruby_complete
-      rcomplete = File.join(K9_ROOT, '/lib/ruby/jruby-complete.jar')
-      return rcomplete if FileTest.exist?(rcomplete)
-      warn "#{rcomplete} does not exist\nTry running `k9 setup install`"
+      ensure_exists(sketch)
+      spin_up('run.rb', sketch, args)
     end
 
-    def parse
-      File.join(K9_ROOT, 'lib/jruby_art/parse.rb')
+    # Run a sketch, keeping an eye on it's file, and reloading
+    # whenever it changes.
+    def watch(sketch, args)
+      ensure_exists(sketch)
+      spin_up('watch.rb', sketch, args)
     end
-    
+
     def setup(choice)
-      usage = 'Usage: k9 setup [install]'
-      installed = FileTest.exist?(File.join(K9_ROOT, '/lib/ruby/jruby-complete.jar'))
       proc_root = FileTest.exist?("#{ENV['HOME']}/.jruby_art/config.yml")
       case choice
-      when /install/  # download and install jruby-complete and unpack examples to user home
-        system "cd #{K9_ROOT}/vendors && rake"
+      when /check/
+        check(proc_root, FileTest.exist?("#{RP5_ROOT}/lib/ruby/jruby-complete.jar"))
+      when /install/
+        install(proc_root)
+      when /unpack_samples/
+        system "cd #{RP5_ROOT}/vendors && rake unpack_samples"
       else
-        puts usage
+        puts 'Usage: k9 setup [check | install | unpack_samples]'
       end
     end
-    
+
+    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 root_exist
+      root ||= "  PROCESSING_ROOT = #{Processing::RP_CONFIG['PROCESSING_ROOT']}"
+      jruby = Processing::RP_CONFIG['JRUBY']
+      x_off = Processing::RP_CONFIG['X_OFF']
+      y_off = Processing::RP_CONFIG['Y_OFF']
+      puts root
+      puts "  JRUBY = #{jruby}" unless jruby.nil?
+      puts "  X_OFF = #{x_off}" unless x_off.nil?
+      puts "  Y_OFF = #{y_off}" unless y_off.nil?
+      puts "  jruby-complete installed = #{installed}"
+    end
+
+    # Display the current version of Ruby-Processing.
+    def show_version
+      puts format('JRubyArt version %s', JRubyArt::VERSION)
+    end
+
     # Show the standard help/usage message.
     def show_help
       puts HELP_MESSAGE
     end
-    
-    # Display the current version of Ruby-Processing.
-    def show_version
-      puts "JRubyArt version #{JRubyArt::VERSION}"
+
+    private
+
+    def core_classpath
+      Dir["#{Processing::RP_CONFIG['PROCESSING_ROOT']}/core/library/\*.jar"]
+    end
+
+    # Trade in this Ruby instance for a JRuby instance, loading in a starter
+    # script and passing it some arguments.Unless '--nojruby' is passed, the
+    # installed version of jruby is used instead of our vendored jarred one
+    # (which is required for some sketches eg shaders). To use
+    # jruby-complete by default set JRUBY: false in ~/.k9rc config
+    # (but that will make using other gems in your sketches hard....)
+    def spin_up(starter_script, sketch, args)
+      runner = "#{RP5_ROOT}/lib/jruby_art/runners/#{starter_script}"
+      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)
+      if @options.nojruby
+        classpath = jruby_complete + core_classpath
+        command = ['java',
+                   java_args,
+                   '-cp',
+                   classpath.join(path_separator),
+                   'org.jruby.Main',
+                   runner,
+                   sketch,
+                   args].flatten
+      else
+        command = ['jruby',
+                   java_args,
+                   '-J-cp',
+                   core_classpath.join(path_separator),
+                   runner,
+                   sketch,
+                   args].flatten
+      end
+      exec(*command)
+      # exec replaces the Ruby process with the JRuby one.
+    end
+
+    def path_separator
+      (host_os == :windows) ? ';' : ':'
+    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
+    # 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 = []
+      args += dock_icon
+      if FileTest.exist?(arg_file)
+        args += File.read(arg_file).split(/\s+/)
+      elsif Processing::RP_CONFIG['java_args']
+        args += Processing::RP_CONFIG['java_args'].split(/\s+/)
+      end
+      args.map! { |arg| "-J#{arg}" } unless @options.nojruby
+      args
+    end
+
+    # NB: We really do mean to use 'and' not '&&' for flow control purposes
+
+    def ensure_exists(sketch)
+      puts "Couldn't find: #{sketch}" and exit unless FileTest.exist?(sketch)
+    end
+
+    def jruby_complete
+      rcomplete = File.join(RP5_ROOT, 'lib/ruby/jruby-complete.jar')
+      return [rcomplete] if FileTest.exist?(rcomplete)
+      warn "#{rcomplete} does not exist\nTry running `k9 setup install`"
+      exit
     end
-  end
-end
 
+    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
+        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 ||= host_os
+      data = {}
+      path = File.expand_path("#{ENV['HOME']}/.jruby_art/config.yml")
+      if os == :mac
+        data['PROCESSING_ROOT'] = '/Applications/Processing.app/Contents/Java'
+      else
+        root = "#{ENV['HOME']}/processing-3.0a10"
+        data['PROCESSING_ROOT'] = root
+      end
+      data['JRUBY'] = 'true'
+      open(path, 'w:UTF-8') { |f| f.write(data.to_yaml) }
+    end
+
+    # On the Mac, we can display a fat, shiny ruby in the Dock.
+    def dock_icon
+      @os ||= host_os
+      icon = []
+      if os == :mac
+        icon << '-Xdock:name=Ruby-Processing'
+        icon << "-Xdock:icon=#{RP5_ROOT}/lib/templates/application/Contents/Resources/sketch.icns"
+      end
+      icon
+    end
+  end # class Runner
+end # module Processing