ruby-processing 1.0.1

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

@@ -0,0 +1,75 @@
+module Processing
+  
+  # A utility class to export Ruby-Processing sketches as applets 
+  # that can be viewed online.
+  class AppletExporter < BaseExporter
+    
+    USAGE = <<-EOS
+    
+    The applet generator will generate a web-ready applet for you.
+    Usage: script/applet <path_to_sketch>
+    Example: script/applet samples/jwishy.rb
+    
+    EOS
+    
+    def export!(sketch)
+      # Check to make sure that the main file exists
+      @main_file_path, @main_file, @main_folder = *get_main_file(sketch)
+      usage(@main_file_path && File.exists?(@main_file_path))
+      
+      extract_information
+      
+      compute_destination_name
+            
+      wipe_and_recreate_destination
+      
+      copy_over_necessary_files
+      
+      process_opengl_replacements
+      
+      calculate_substitutions
+      
+      render_erb_in_path_with_binding(@dest, binding, :delete => true)
+    end
+    
+    def compute_destination_name
+      @dest = "#{@main_file.sub(".rb", "")}"
+    end
+    
+    def copy_over_necessary_files
+      @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_files += Dir["#{RP5_ROOT}/lib/templates/applet/{*,**}"]
+      @necessary_files += Dir.glob("library/{#{@libraries.join(",")}}") unless @libraries.empty?
+      @necessary_files.uniq!
+      cp_r(@necessary_files, @dest)
+      cp_r(@libraries, File.join(@dest, "library")) unless @libraries.empty?
+    end
+    
+    def process_opengl_replacements
+      @starting_class = @opengl ? "com.sun.opengl.util.JOGLAppletLauncher" : "org.jruby.JRubyApplet"
+      return unless @opengl
+      opengl_files = Dir["#{@dest}/library/opengl/*.jar"]
+      opengl_files += Dir["#{@dest}/library/opengl/library/*.jar"]
+      move(opengl_files, @dest)
+      opengl_dir = "#{@dest}/library/opengl"
+      remove_entry_secure(opengl_dir) if File.exists?(opengl_dir)
+      @necessary_files.map! {|file| file.match(/^opengl/) ? File.basename(file) : file }
+    end
+    
+    def calculate_substitutions
+      file_list = Dir.glob(@dest + "{/**/*.{rb,jar},/data/*.*}").map {|f| f.sub(@dest+"/","")}
+      @width_plus_14 = (@width.to_i + 14).to_s
+      @file_list = file_list.join(",")
+    end
+    
+    def usage(predicate)
+      return if predicate
+      puts USAGE
+      exit
+    end
+    
+  end
+end

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

@@ -0,0 +1,87 @@
+module Processing
+  
+  # A utility class to export Ruby-Processing sketches as 
+  # Mac/Win/Nix Applications.
+  class ApplicationExporter < BaseExporter
+    
+    USAGE = <<-EOS
+        
+    The application exporter will generate a Mac application for you.
+    Usage: script/application <path_to_sketch>
+    Example: script/applet samples/jwishy.rb 
+      
+    EOS
+    
+    def export!(sketch)
+      # Check to make sure that the main file exists
+      @main_file_path, @main_file, @main_folder = *get_main_file(sketch)
+      usage( @main_file_path && File.exists?(@main_file_path) )
+      
+      extract_information
+      
+      compute_destination_name
+      
+      wipe_and_recreate_destination
+      
+      copy_over_necessary_files
+      
+      calculate_substitutions
+      
+      create_executables
+      
+      symlink_library_into_place
+    end
+    
+    def compute_destination_name
+      @dest = "#{@title}.app"
+    end
+    
+    def copy_over_necessary_files
+      @prefix = "lib"
+      cp_r(Dir["#{RP5_ROOT}/lib/templates/application/{*,**}"], @dest)
+      @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_files.uniq!
+      cp_r(@necessary_files, File.join(@dest, @prefix))
+      cp_r(@libraries, File.join(@dest, @prefix, "library")) unless @libraries.empty?
+      # Then move the icon
+      potential_icon = Dir.glob(File.join(@dest, @prefix, "data/*.icns"))[0]
+      move(potential_icon, File.join(@dest, "Contents/Resources/sketch.icns"), :force => true ) if potential_icon
+    end
+    
+    def calculate_substitutions
+      file_list = Dir.glob(@dest + "{/**/*.{rb,jar},/data/*.*}").map {|f| f.sub(@dest + "/", "")}
+      @class_path = file_list.map {|f| "$JAVAROOT/" + f.sub(@prefix+"/", "") }.join(":")
+      @linux_class_path = file_list.map{|f| f.sub(@prefix+"/", "")}.join(":")
+      @windows_class_path = file_list.map{|f| f.sub(@prefix+"/", "")}.join(",")
+    end
+    
+    def create_executables
+      render_erb_in_path_with_binding(@dest, binding, :delete => true)
+      rm Dir.glob(@dest + "/**/*.java")
+      runnable = @dest + "/" + File.basename(@main_file, ".rb")
+      move @dest + "/run", runnable
+      move @dest + "/run.exe", "#{runnable}.exe"
+      chmod 0755, runnable
+      chmod 0755, "#{runnable}.exe"
+    end
+    
+    def symlink_library_into_place
+      cd @dest + "/Contents/Resources"
+      # Poor ol' windows can't symlink.
+      # TODO...
+      win = RUBY_PLATFORM.match(/mswin/)
+      puts "\n[warning] Applications exported from Windows won't run on Macs...\n" if win 
+      ln_s('../../lib', 'Java') unless win
+    end
+    
+    def usage(predicate)
+      return if predicate
+      puts USAGE
+      exit
+    end
+    
+  end
+end

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

@@ -0,0 +1,133 @@
+require 'fileutils'
+require 'erb'
+
+module Processing
+  
+  # This base exporter implements some of the common 
+  # code-munging needed to generate apps and applets.
+  class BaseExporter
+    include FileUtils
+    
+    DEFAULT_TITLE = "Ruby-Processing Sketch"
+    DEFAULT_DIMENSIONS = {'width' => '500', 'height' => '500'}
+    DEFAULT_DESCRIPTION = ''
+    
+    # Returns the filepath, basename, and directory name of the sketch.
+    def get_main_file(file)
+      return file, File.basename(file), File.dirname(file)
+    end
+    
+    # Centralized method to read the source of the sketch and extract
+    # all the juicy details.
+    def extract_information
+      # Extract information from main file
+      @info = {}
+      @info[:source_code]     = source = read_source_code
+      @info[:class_name]      = extract_class_name(source)
+      @info[:title]           = extract_title(source)
+      @info[:width]           = extract_dimension(source, 'width')
+      @info[:height]          = extract_dimension(source, 'height')
+      @info[:description]     = extract_description(source)
+      @info[:libraries]       = extract_libraries(source)
+      @info[:real_requires]   = extract_real_requires(source)
+      hash_to_ivars @info
+      @info
+    end
+    
+    # Searches the source for a class name.
+    def extract_class_name(source)
+      match = source.match(/(\w+)\s*<\s*Processing::App/)
+      match ? match[1] : nil
+    end
+    
+    # Searches the source for a title.
+    def extract_title(source)
+      match = source.match(/#{@info[:class_name]}\.new.*?:title\s=>\s["'](.+)["']/m)
+      match ? match[1] : DEFAULT_TITLE
+    end
+    
+    # Searches the source for the width and height of the sketch.
+    def extract_dimension(source, dimension)
+      match = source.match(/#{@info[:class_name]}\.new.*?:#{dimension}\s=>\s(\d+)/m)
+      match ? match[1] : DEFAULT_DIMENSIONS[dimension]
+    end
+    
+    # Searches the source for a description of the sketch.
+    def extract_description(source)
+      match = source.match(/# Description:(.*?)\n[^#]/m)
+      match ? match[1].gsub!(/\n(\s*)?#/, "") : DEFAULT_DESCRIPTION
+    end
+    
+    # Searches the source any libraries that have been loaded.
+    def extract_libraries(source)
+      libs = []
+      code = source.dup
+      loop do
+        matchdata = code.match(/load_\w+_library.+?["':](\S+?)["'\s]/)
+        break unless matchdata
+        match = matchdata[1]
+        @opengl = true if match.match(/opengl/i)
+        local_path = "#{local_dir}/library/#{match}"
+        rp5_path = "#{RP5_ROOT}/library/#{match}"
+        File.exists?(local_path) ? libs << local_path : 
+          (libs << rp5_path if File.exists?(rp5_path))
+        code = matchdata.post_match
+      end
+      libs
+    end
+    
+    # Looks for all of the codes require or load commands, checks 
+    # to see if the file exists (that it's not a gem, or a standard lib) 
+    # and hands you back all the real ones.
+    def extract_real_requires(source)
+      code = source.dup
+      requirements = []
+      partial_paths = []
+      loop do
+        matchdata = code.match(/^.*\b(require|load)\b.*$/)
+        break unless matchdata
+        line = matchdata[0].gsub('__FILE__', "'#{@main_file_path}'")
+        line = line.gsub(/\b(require|load)\b/, 'partial_paths << ')
+        eval(line)
+        requirements += Dir["{#{local_dir}/,}{#{partial_paths.join(',')}}.{rb,jar}"]
+        code = matchdata.post_match
+      end
+      return requirements
+    end
+    
+    
+    protected
+    
+    def read_source_code
+      File.read(@main_file_path)
+    end
+    
+    def local_dir
+      File.dirname(@main_file_path)
+    end
+    
+    def hash_to_ivars(hash)
+      hash.each{|k,v| instance_variable_set("@" + k.to_s, v) }
+    end
+    
+    def wipe_and_recreate_destination
+      remove_entry_secure @dest if File.exists?(@dest)
+      mkdir_p @dest
+    end
+    
+    def render_erb_in_path_with_binding(path, some_binding, opts={})
+      erbs = Dir.glob(path + "/**/*.erb")
+      erbs.each do |erb|
+        string = File.open(erb) {|f| f.read }
+        rendered = render_erb_from_string_with_binding(string, some_binding)
+        File.open(erb.sub(".erb", ""), "w") {|f| f.print rendered }
+        rm erb if opts[:delete]
+      end
+    end
+    
+    def render_erb_from_string_with_binding(erb, some_binding)
+      rendered = ERB.new(erb, nil, "<>", "rendered").result(some_binding)
+    end
+    
+  end
+end

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

@@ -0,0 +1,46 @@
+module Processing
+  
+  # This class creates blank sketches, with the boilerplate filled in.
+  class Creator < BaseExporter
+    
+    # Create a blank sketch, given a path.
+    def create!(path, args)
+      usage path
+      main_file = File.basename(path, ".rb")
+      # Check to make sure that the main file exists
+      already_exists = File.exists?(path) || File.exists?("#{File.dirname(path)}/#{main_file.underscore}.rb")
+      puts "That sketch already exists." and exit if already_exists
+      
+      # Get the substitutions
+      @name =       main_file.camelize
+      @file_name =  main_file.underscore
+      @title =      main_file.titleize
+      @width =      args[0] || "500"
+      @height =     args[1] || "500"
+  
+      # Make the file
+      dir = File.dirname path
+      mkdir_p dir
+      template = File.new("#{RP5_ROOT}/lib/templates/create/blank_sketch.rb.erb")
+      rendered = render_erb_from_string_with_binding(template.read, binding)
+      File.open(File.join(dir, "#{@file_name}.rb"), "w") do |file|
+        file.print rendered
+      end
+    end
+    
+    # Show the help/usage message for create.
+    def usage(predicate)
+      unless predicate
+        puts <<-USAGE
+  
+      Usage: script/generate <sketch_to_generate> <width> <height>
+      Width and Height are optional.
+      
+      Example: script/generate fancy_drawing/app 800 600
+  
+      USAGE
+        exit
+      end
+    end
+  end
+end

data/lib/ruby-processing/helpers/string.rb

@@ -0,0 +1,27 @@
+class String #:nodoc:
+  
+  def titleize
+    self.underscore.humanize.gsub(/\b([a-z])/) { $1.capitalize }
+  end
+  
+  def humanize()
+    self.gsub(/_id$/, "").gsub(/_/, " ").capitalize
+  end
+  
+  def camelize(first_letter_in_uppercase = true)
+    if first_letter_in_uppercase
+      self.gsub(/\/(.?)/) { "::" + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+    else
+      self.first + self.camelize[1..-1]
+    end
+  end
+  
+  def underscore
+    self.gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+  end
+  
+end

data/lib/ruby-processing/runner.rb

@@ -0,0 +1,143 @@
+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 640 480
+    rp5 watch some_new_sketch.rb
+    rp5 applet some_new_sketch.rb
+    
+  Further information:
+    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'    : run(@options.path)
+      when 'watch'  : watch(@options.path)
+      when 'create' : create(@options.path, @options.args)
+      when 'live'   : live(@options.path)
+      when 'app'    : app(@options.path)
+      when 'applet' : applet(@options.path)
+      when 'unpack' : unpack(@options.path)
+      when /-v/     : show_version
+      when /-h/     : show_help
+      else show_help
+      end
+    end
+    
+    # Parse the command-line options. Keep it simple.
+    def parse_options(args)
+      @options = OpenStruct.new
+      @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)
+      Processing::Creator.new.create!(sketch, args)
+    end
+    
+    # Just simply run a ruby-processing sketch.
+    def run(sketch)
+      ensure_exists(sketch)
+      spin_up('run.rb', sketch)
+    end
+    
+    # Run a sketch, keeping an eye on it's file, and reloading
+    # whenever it changes.
+    def watch(sketch)
+      ensure_exists(sketch)
+      spin_up('watch.rb', sketch)
+    end
+    
+    # Run a sketch, opening its guts to IRB, letting you play with it.
+    def live(sketch)
+      ensure_exists(sketch)
+      spin_up('live.rb', sketch)
+    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 
+    # 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}")
+    end
+    
+    # Display the current version of Ruby-Processing.
+    def show_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 
+    # starter script and passing it some arguments.
+    def spin_up(starter_script, args)
+      runner = "#{RP5_ROOT}/lib/ruby-processing/runners/#{starter_script}"
+      command = "java -cp #{jruby_complete} #{dock_icon} org.jruby.Main #{runner} #{args}"
+      exec(command)
+      # exec replaces the Ruby process with the JRuby one.
+    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)
+      mac ? "-Xdock:name=Ruby-Processing -Xdock:icon=#{RP5_ROOT}/lib/templates/application/Contents/Resources/sketch.icns" : ""
+    end
+    
+  end # class Runner
+  
+end # module Processing