ruby-processing 2.4.4 → 2.5.0

data/lib/ruby-processing/runner.rb

@@ -1,8 +1,8 @@
 require 'ostruct'
 require 'fileutils'
 require 'rbconfig'
-require_relative 'config'
-require_relative 'version'
+require_relative '../ruby-processing/config'
+require_relative '../ruby-processing/version'
 
 
 module Processing
@@ -11,47 +11,37 @@ module Processing
   # offers. Able to run, watch, live, create, app, and unpack
   class Runner
     HELP_MESSAGE = <<-EOS
-  Version: #{RubyProcessing::VERSION}
-
-  Ruby-Processing is a little shim between Processing and JRuby that helps
-  you create sketches of code art.
-
-  Usage:
-    rp5 [run | watch | live | create [width height] | app | unpack] path/to/sketch
-
-    run:        run sketch once
-    watch:      watch for changes on the file and relaunch it on the fly
-    live:       launch sketch and give an interactive IRB shell
-    create:     create new sketch. Use --bare to generate simpler sketches without a class
-    app:        create an application version of the sketch
-    unpack:     unpack samples or library
-
-  Common options:
-    --nojruby:  do not use the installed version of jruby, instead use our vendored
-                jarred one (required for shader sketches, and some others).
-  
-  Configuration file:
-    A YAML configuration file is located at {Processing::CONFIG_FILE_PATH}
-    
-    Possible options are:
-
-      java_args:        pass additionnals arguments to Java VM upon launching. 
-                        Useful for increasing available memory (for example:
-                        -Xms256m -Xmx256m) or force 32 bits mode (-d32).
-      sketchbook_path:  specify Processing sketchbook path to load additionnal 
-                        libraries
-
-  Examples:
-    rp5 unpack samples
+    Version: #{RubyProcessing::VERSION}
+
+    Ruby-Processing is a little shim between Processing and JRuby that helps
+    you create sketches of code art.
+
+    Usage:
+    rp5 [choice] path/to/sketch
+
+    choice:-
+    run:              run sketch once
+    watch:            watch for changes on the file and relaunch it on the fly
+    live:                  launch sketch and give an interactive IRB shell
+    create [width height]: create a new sketch.
+    app:              create an application version of the 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 .rp5rc to make using jruby-complete default)
+
+    Examples:
+    rp5 setup unpack_samples
     rp5 run samples/contributed/jwishy.rb
     rp5 create some_new_sketch 640 480
     rp5 create some_new_sketch --p3d 640 480
     rp5 watch some_new_sketch.rb
 
-  Everything Else:
+    Everything Else:
     http://wiki.github.com/jashkenas/ruby-processing
 
-      EOS
+    EOS
 
     # Start running a ruby-processing sketch from the passed-in arguments
     def self.execute
@@ -68,7 +58,7 @@ module Processing
       when 'live'   then live(@options.path, @options.args)
       when 'create' then create(@options.path, @options.args, @options.p3d)
       when 'app'    then app(@options.path)
-      when 'unpack' then unpack(@options.path)
+      when 'setup'  then setup(@options.path)
       when /-v/     then show_version
       when /-h/     then show_help
       else
@@ -79,9 +69,9 @@ module Processing
     # Parse the command-line options. Keep it simple.
     def parse_options(args)
       @options = OpenStruct.new
-      @options.p3d   = !!args.delete('--p3d')
-      @options.jruby  = !!args.delete('--jruby')
-      @options.nojruby  = !!args.delete('--nojruby')
+      @options.p3d   = !args.delete('--p3d').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] || []
@@ -90,42 +80,66 @@ module Processing
     # Create a fresh Ruby-Processing sketch, with the necessary
     # boilerplate filled out.
     def create(sketch, args, p3d)
+      require_relative '../ruby-processing/exporters/creator'
       Processing::Creator.new.create!(sketch, args, p3d)
     end
 
     # Just simply run a ruby-processing sketch.
     def run(sketch, args)
-      ensure_exists(sketch)
+    ensure_exists(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, args)
-      ensure_exists(sketch)
+    ensure_exists(sketch)
       spin_up('watch.rb', sketch, args)
     end
 
     # Run a sketch, opening its guts to IRB, letting you play with it.
     def live(sketch, args)
-      ensure_exists(sketch)
+    ensure_exists(sketch)
       spin_up('live.rb', sketch, args)
     end
 
     # Generate a cross-platform application of a given Ruby-Processing sketch.
     def app(sketch)
+      require_relative '../ruby-processing/exporters/application_exporter'
       Processing::ApplicationExporter.new.export!(sketch)
     end
 
-    # 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'
-      usage = "Usage: rp5 unpack [samples | library]"
-      puts usage and return unless dir.match(/\A(samples|library)\Z/)
-      FileUtils.cp_r("#{RP5_ROOT}/#{dir}", "#{Dir.pwd}/#{dir}")
+    def setup(choice)
+      usage = 'Usage: rp5 setup [check | install | unpack_samples]'
+      installed = File.exist?("#{RP5_ROOT}/lib/ruby/jruby-complete.jar")
+      proc_root = File.exist?("#{ENV['HOME']}/.rp5rc")
+      case choice
+      when /check/
+        check(proc_root, installed)
+      when /install/
+        system "cd #{RP5_ROOT}/vendors && rake"
+        if !proc_root
+          set_processing_root
+          warn 'PROCESSING_ROOT set optimistically, run check to confirm'
+        end
+      when /unpack_samples/
+        require 'fileutils'
+        FileUtils.cp_r("#{RP5_ROOT}/samples", "#{Dir.pwd}/rp_samples")
+      else
+        puts usage
+      end
     end
 
+    def check(proc_root, installed)
+      show_version
+      root = '  PROCESSING_ROOT = Not Set!!!' unless proc_root
+      root ||= "  PROCESSING_ROOT = #{Processing::RB_CONFIG['PROCESSING_ROOT']}"
+      puts root
+      puts "  JRUBY = #{Processing::RB_CONFIG['JRUBY']}"
+      puts "  jruby-complete installed = #{installed}"
+    end
+
+
     # Display the current version of Ruby-Processing.
     def show_version
       puts "Ruby-Processing version #{RubyProcessing::VERSION}"
@@ -143,14 +157,16 @@ module Processing
     # starter script and passing it some arguments.
     # Unless --nojruby is passed, use the installed version of jruby, instead of
     # our vendored jarred one (vendored version is required for some sketches eg shaders).
+    # For people with system jruby they can use ~.rp5rc config to use option without flag
     def spin_up(starter_script, sketch, args)
       runner = "#{RP5_ROOT}/lib/ruby-processing/runners/#{starter_script}"
+      warn('The --jruby flag is no longer required') if @options.jruby
+      @options.nojruby = true if Processing::RB_CONFIG['JRUBY'] == 'false'
       java_args = discover_java_args(sketch)
-      warn("The --jruby flag is no longer required") if @options.jruby
       command = @options.nojruby ?
-         ['java', java_args, '-cp', jruby_complete, 'org.jruby.Main', runner, sketch, args].flatten :
-         ['jruby', java_args, runner, sketch, args].flatten                
-      exec *command
+        ['java', java_args, '-cp', jruby_complete, 'org.jruby.Main', runner, sketch, args].flatten :
+        ['jruby', java_args, runner, sketch, args].flatten
+      exec(*command)
       # exec replaces the Ruby process with the JRuby one.
     end
 
@@ -163,10 +179,10 @@ module Processing
       args += dock_icon
       if File.exist?(arg_file)
         args += File.read(arg_file).split(/\s+/)
-      elsif Processing::CONFIG["java_args"]
-        args += Processing::CONFIG["java_args"].split(/\s+/)
+      elsif Processing::RB_CONFIG['java_args']
+        args += Processing::RB_CONFIG['java_args'].split(/\s+/)
       end
-      args.map! {|arg| "-J#{arg}" } unless @options.nojruby
+      args.map! { |arg| "-J#{arg}" } unless @options.nojruby
       args
     end
 
@@ -179,18 +195,55 @@ module Processing
       if File.exist?(rcomplete)
         return rcomplete
       else
-	warn "#{rcomplete} does not exist\nTry running `install_jruby_complete`"
-	exit
-      end	      
+        warn "#{rcomplete} does not exist\nTry running `rp5 setup install`"
+        exit
+      end
+    end
+
+    def os
+      @os ||=
+        host_os = RbConfig::CONFIG['host_os']
+        case host_os
+        when /mswin|msys|mingw|cygwin|bccwin|wince|emc/
+          :windows
+        when /darwin|mac os/
+          :macosx
+        when /linux/
+          :linux
+        when /solaris|bsd/
+          :unix
+        else
+          raise "unknown os: #{host_os.inspect}"
+        end
+    end
+
+
+    # Optimistically set processing root
+    def set_processing_root
+      require 'psych'
+      os
+      data = {}
+      path = File.expand_path("#{ENV['HOME']}/.rp5rc")
+      if @os == :macosx
+        data['PROCESSING_ROOT'] = %q(/Applications/Processing.app/Contents/Java')
+      else
+        root = "#{ENV['HOME']}/processing-2.2.1"
+        data['PROCESSING_ROOT'] = root
+      end
+      data['JRUBY'] = %q(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
-      mac ||= RbConfig::CONFIG['host_os'].match(/darwin/i) 
-      mac ||= RbConfig::CONFIG['host_os'].match(/mac/i) 
-      mac ? ["-Xdock:name=Ruby-Processing", "-Xdock:icon=#{RP5_ROOT}/lib/templates/application/Contents/Resources/sketch.icns"] : []
+      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
+

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

@@ -1,38 +1,36 @@
 # -*- encoding : utf-8 -*-
 
-$LOAD_PATH << File.expand_path(File.dirname(__FILE__) + "/../../")
-SKETCH_PATH = ARGV.shift unless defined? SKETCH_PATH
-SKETCH_ROOT = File.dirname(SKETCH_PATH) unless defined? SKETCH_ROOT
+SKETCH_PATH ||= ARGV.shift
+SKETCH_ROOT ||= File.dirname(SKETCH_PATH)
 
-require 'ruby-processing'
-require 'ruby-processing/app'
+require_relative '../../ruby-processing'
+require_relative '../../ruby-processing/app'
 
 module Processing
-
   # For use with "bare" sketches that don't want to define a class or methods
   SKETCH_TEMPLATE = <<-EOS
-    class Sketch < Processing::App
-      <% if has_methods %>
-      <%= source %>
-      <% else %>
-      def setup
-        size(DEFAULT_WIDTH, DEFAULT_HEIGHT, JAVA2D)
-        <%= source %>
-        no_loop
-      end
-      <% end %>
-    end
+  class Sketch < Processing::App
+  <% if has_methods %>
+  <%= source %>
+  <% else %>
+  def setup
+  size(DEFAULT_WIDTH, DEFAULT_HEIGHT, JAVA2D)
+  <%= source %>
+  no_loop
+  end
+  <% end %>
+  end
   EOS
 
   # This method is the common entry point to run a sketch, bare or complete.
   def self.load_and_run_sketch
-    source = self.read_sketch_source
-    has_sketch = !!source.match(/^[^#]*< Processing::App/)
-    has_methods = !!source.match(/^[^#]*(def\s+setup|def\s+draw)/)
+    source = read_sketch_source
+    has_sketch = !source.match(/^[^#]*< Processing::App/).nil?
+    has_methods = !source.match(/^[^#]*(def\s+setup|def\s+draw)/).nil?
 
     if has_sketch
-      load File.join(SKETCH_ROOT, SKETCH_PATH)      
-      Processing::App.sketch_class.new if !$app
+      load File.join(SKETCH_ROOT, SKETCH_PATH)
+      Processing::App.sketch_class.new unless $app
     else
       require 'erb'
       code = ERB.new(SKETCH_TEMPLATE).result(binding)
@@ -41,11 +39,8 @@ module Processing
     end
   end
 
-
   # Read in the sketch source code. Needs to work both online and offline.
   def self.read_sketch_source
-      source = File.read(SKETCH_PATH)
-    source
+    File.read(SKETCH_PATH)
   end
-
 end

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

@@ -1,9 +1,8 @@
-# An IRB shell for live coding. 
-# This flavor will either load up empty Ruby-Processing, 
+# An IRB shell for live coding.
+# This flavor will either load up empty Ruby-Processing,
 # or will start with your sketch.
 
-root = File.dirname(__FILE__)
-require "#{root}/base.rb"
+require_relative '../../ruby-processing/runners/base'
 Processing.load_and_run_sketch
 
 ARGV.clear # So that IRB doesn't try to load them as files.

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

@@ -1,8 +1,6 @@
 # TODO: this is crud. Windows applets are having serious
 # trouble with absolute paths.
 
-# root = defined?(JRUBY_APPLET) ? 'ruby-processing/runners' : File.dirname(__FILE__)
-root = File.dirname(__FILE__)
-require "#{root}/base.rb"
+require_relative '../runners/base'
 
 Processing.load_and_run_sketch

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

@@ -1,4 +1,4 @@
-require "#{File.dirname(__FILE__)}/base.rb"
+require_relative '../runners/base'
 
 module Processing
 
@@ -19,10 +19,10 @@ module Processing
     def start_watching
       start_runner
       loop do
-        if @files.detect { |file| File.exist?(file) && File.stat(file).mtime > @time }
-          puts "reloading sketch..."
+        if @files.find { |file| File.exist?(file) && File.stat(file).mtime > @time }
+          puts 'reloading sketch...'
           $app && $app.close
-          @time = Time.now                
+          @time = Time.now
           java.lang.System.gc
           start_runner
           reload_files_to_watch
@@ -40,17 +40,17 @@ module Processing
       puts "Backtrace:\n\t#{e.backtrace.join("\n\t")}"
     end
 
-    def start_runner 
+    def start_runner
       @runner.kill if @runner && @runner.alive?
-      @runner = Thread.start do 
-        report_errors do 
+      @runner = Thread.start do
+        report_errors do
           Processing.load_and_run_sketch
         end
       end
     end
 
     def reload_files_to_watch
-      @files = ([SKETCH_PATH] + Dir.glob(File.dirname(SKETCH_PATH) + "/*.rb")).uniq
+      @files = ([SKETCH_PATH] + Dir.glob(File.dirname(SKETCH_PATH) + '/*.rb')).uniq
     end
   end
 end

data/lib/ruby-processing/version.rb

@@ -1,3 +1,3 @@
 module RubyProcessing
-  VERSION="2.4.4"
+  VERSION = '2.5.0'
 end

data/lib/templates/application/lib/args.txt.erb

@@ -1,3 +1,3 @@
-set EXPORTED="true"
+set EXPORTED='true'
 org.jruby.Main lib/ruby-processing/runners/run.rb lib/<%= @main_file %>
 <%= @windows_class_path %>

data/lib/templates/application/run.erb

@@ -1,5 +1,5 @@
 #!/bin/sh
-APPDIR=$(dirname "$0")
-export EXPORTED="true"
-cd "$APPDIR/lib"
+APPDIR=$(dirname '$0')
+export EXPORTED='true'
+cd '$APPDIR/lib'
 java -cp "<%= @linux_class_path %>" org.jruby.Main ../lib/ruby-processing/runners/run.rb <%= @main_file %>

data/library/control_panel/control_panel.rb

@@ -6,7 +6,7 @@
 # (optionally) pass the range and default value.
 
 module ControlPanel
-
+  
   class Slider < javax.swing.JSlider
     def initialize(control_panel, name, range, initial_value, proc=nil)
       min = range.begin * 100
@@ -25,21 +25,21 @@ module ControlPanel
       set_value(initial_value ? initial_value*100 : min)
       fire_state_changed
     end
-
+    
     def value
       get_value / 100.0
     end
-
+    
     def update_label(label, name, value)
       value = value.to_s
-      value << "0" if value.length < 4
+      value << '0' if value.length < 4
       label.set_text "<html><br><b>#{name.to_s}: #{value}</b></html>"
     end
   end
-
-
+  
+  
   class Menu < javax.swing.JComboBox
-    def initialize(control_panel, name, elements, initial_value, proc=nil)
+    def initialize(control_panel, name, elements, initial_value, proc = nil)
       super(elements.to_java(:String))
       set_preferred_size(java.awt.Dimension.new(190, 30))
       control_panel.add_element(self, name)
@@ -49,13 +49,13 @@ module ControlPanel
       end
       set_selected_index(initial_value ? elements.index(initial_value) : 0)
     end
-
+    
     def value
       get_selected_item
     end
   end
-
-
+  
+  
   class Checkbox < javax.swing.JCheckBox
     def initialize(control_panel, name, proc=nil)
       @control_panel = control_panel
@@ -68,13 +68,13 @@ module ControlPanel
         proc.call(value) if proc
       end
     end
-
+    
     def value
       is_selected
     end
   end
-
-
+  
+  
   class Button < javax.swing.JButton
     def initialize(control_panel, name, proc=nil)
       super(name.to_s)
@@ -86,19 +86,19 @@ module ControlPanel
       end
     end
   end
-
-
+  
+  
   class Panel < javax.swing.JFrame
     java_import javax.swing.UIManager
     
     attr_accessor :elements, :panel
-
+    
     def initialize 
       super()
       @elements = []
       @panel = javax.swing.JPanel.new(java.awt.FlowLayout.new(1, 0, 0))
     end
-
+    
     def display
       add panel
       set_size 200, 30 + (64 * elements.size)
@@ -107,7 +107,7 @@ module ControlPanel
       set_location($app.width + 10, 0) unless ($app.width + 10 > $app.displayWidth)
       panel.visible = true
     end
-
+    
     def add_element(element, name, has_label=true, button=false)
       if has_label
         label = javax.swing.JLabel.new("<html><br><b>#{name}</b></html>")
@@ -117,37 +117,37 @@ module ControlPanel
       panel.add element
       return has_label ? label : nil
     end
-
+    
     def remove
       remove_all
       dispose
     end
-
+    
     def slider(name, range=0..100, initial_value = nil, &block)
       slider = Slider.new(self, name, range, initial_value, block || nil)
     end
-
+    
     def menu(name, elements, initial_value = nil, &block)
       menu = Menu.new(self, name, elements, initial_value, block || nil)
     end
-
+    
     def checkbox(name, initial_value = nil, &block)
       checkbox = Checkbox.new(self, name, block || nil)
       checkbox.do_click if initial_value == true
     end
-
+    
     def button(name, &block)
       button = Button.new(self, name, block || nil)
     end
-
-    def look_feel lf = "Metal"
-      lafs = javax.swing.UIManager::getInstalledLookAndFeels.select{|info| info.getName.eql? lf}
+    
+    def look_feel(lf = 'Metal') 
+      lafs = javax.swing.UIManager::getInstalledLookAndFeels.select { |info| info.getName.eql? lf }
       javax.swing.UIManager::setLookAndFeel(lafs[0].getClassName) if lafs.size > 0
     end
-
+    
   end
-
-
+  
+  
   module InstanceMethods
     def control_panel 
       @control_panel = ControlPanel::Panel.new unless @control_panel