jruby_art 0.2.0.pre

data/lib/jruby_art/config.rb

@@ -0,0 +1,18 @@
+require 'psych'
+
+module Processing
+
+  unless defined? RP_CONFIG
+    begin
+      CONFIG_FILE_PATH = File.expand_path('~/.jruby_art/config.yml')
+      File.open(CONFIG_FILE_PATH, 'r') do |yaml|
+        RP_CONFIG = Psych.load(yaml)
+      end
+    rescue
+      warn('WARNING: you need to set PROCESSING_ROOT in ~/.jruby_art/config.yml')
+    end
+  end
+end
+
+
+

data/lib/jruby_art/creator.rb

@@ -0,0 +1,100 @@
+CLASS_BASIC = <<-CODE
+require 'jruby_art'
+
+class %s < Processing::App
+  def setup
+    size %s, %s
+  end
+
+  def draw
+
+  end
+end
+
+%s.new(title: '%s')
+CODE
+
+CLASS_MODE = <<-CODE
+require 'jruby_art'
+
+class %s < Processing::AppGL
+  def setup
+    size %s, %s, %s
+  end
+
+  def draw
+
+  end
+end
+
+%s.new(title: '%s')
+CODE
+
+module Processing
+  require_relative '../jruby_art/helpers/string_extra'
+  require_relative '../jruby_art/helpers/camel_string'
+  # Write file to disk
+  class SketchWriter
+    attr_reader :file
+    def initialize(path)
+      underscore = StringExtra.new(path).underscore
+      @file = "#{File.dirname(path)}/#{underscore}.rb"
+    end
+
+    def save(template)
+      File.open(file, 'w+') do |f|
+        f.write(template)
+      end
+    end
+  end
+
+  # An abstract class providing common methods for real creators
+  class Creator
+    ALL_DIGITS = /\A\d+\Z/
+
+    def already_exist(path)
+      underscore = StringExtra.new(path).underscore
+      new_file = "#{File.dirname(path)}/#{underscore}.rb"
+      return if !File.exist?(path) && !File.exist?(new_file)
+      puts 'That file already exists!'
+      exit
+    end
+
+    # Show the help/usage message for create.
+    def usage
+      puts <<-USAGE
+
+      Usage: k9 create <sketch_to_generate> <width> <height>
+      Examples: k9 create my_app 800 600
+                k9 create my_app 800 600 p3d
+
+      USAGE
+    end
+  end
+
+  # This class creates class wrapped sketches, with an optional render mode
+  class ClassSketch < Creator
+    def class_template
+      format(CLASS_BASIC, @name, @width, @height, @name, @title)
+    end
+
+    def class_template_mode
+      format(CLASS_MODE, @name, @width, @height, @mode, @name, @title)
+    end
+
+    # Create a bare blank sketch, given a path.
+    def create!(path, args)
+      return usage if /\?/ =~ path || /--help/ =~ path
+      main_file = File.basename(path, '.rb') # allow uneeded extension input
+      # Check to make sure that the main file doesn't exist already
+      already_exist(path)
+      @name = CamelString.new(main_file).camelize
+      writer = SketchWriter.new(main_file)
+      @title = StringExtra.new(main_file).titleize
+      @width, @height = args[0], args[1]
+      @mode = args[2].upcase unless args[2].nil?
+      template = @mode.nil? ? class_template : class_template_mode
+      writer.save(template)
+    end
+  end
+end

data/lib/jruby_art/helper_methods.rb

@@ -0,0 +1,220 @@
+module Processing
+  module HelperMethods
+    # processings epsilon may not be defined yet
+    EPSILON ||= 1.0e-04
+    # Nice block method to draw to a buffer.
+    # You can optionally pass it a width, a height, and a renderer.
+    # Takes care of starting and ending the draw for you.
+    def buffer(buf_width = width, buf_height = height, renderer = @render_mode)
+      buf = create_graphics(buf_width, buf_height, renderer)
+      buf.begin_draw
+      yield buf
+      buf.end_draw
+      buf
+    end
+
+    # A nice method to run a given block for a grid.
+    # Lifted from action_coding/Nodebox.
+    def grid(cols, rows, col_size = 1, row_size = 1)
+      (0...cols * rows).map do |i|
+        x = col_size * (i % cols)
+        y = row_size * i.div(cols)
+        yield x, y
+      end
+    end
+
+    # lerp_color takes three or four arguments, in Java that's two
+    # different methods, one regular and one static, so:
+    def lerp_color(*args)
+      args.length > 3 ? self.class.lerp_color(*args) : super(*args)
+    end
+
+    def color(*args)
+      a = args[0]
+      # convert to signed int
+      if args.length == 1
+        if a.is_a?(Fixnum) && a >= 2**31
+          args = [a - 2**32]
+        elsif a.is_a?(String) && a[0].eql?('#')
+          h = a[1..-1].rjust(6, '0').prepend('ff')
+          return color(h.hex)
+        end
+      end
+      super(*args)
+    end
+
+    # Overrides Processing convenience function thread, which takes a String
+    # arg (for a function) to more rubylike version, takes a block...
+    def thread(&block)
+      if block_given?
+        Thread.new(&block)
+      else
+        fail ArgumentError, 'thread must be called with a block', caller
+      end
+    end
+
+    # Explicitly provides 'processing.org' map instance method, in which
+    # value is mapped from range 1, to range 2 (NB: values are not clamped to
+    # range 1). It may be better to explicitly write your own interpolate
+    # function
+    # @param [float] value input
+    # @param [range] start1, stop1
+    # @param [range] start1, stop2
+    # @return [float] mapped value
+    def map(value, start1, stop1, start2, stop2)
+      start2 + (stop2 - start2) * ((value - start1).to_f / (stop1 - start1))
+    end
+
+    # ruby alternative implementation of map using range parameters
+    # (begin..end) and excluded end (begin...end) produce the same result
+    def map1d(val, r_in, r_out)
+      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)
+    end
+
+    # explicitly provide 'processing.org' lerp instance method
+    def lerp(start, stop, amt)
+      start + (stop - start) * amt
+    end
+
+    # explicitly provide 'processing.org' min instance method
+    # to return a float:- a, b and c need to be floats
+
+    def min(*args)
+      args.min  #  { |a,b| a <=> b } optional block not reqd
+    end
+
+    # explicitly provide 'processing.org' max instance method
+    # to return a float:- a, b and c need to be floats
+
+    def max(*args)
+      args.max  #  { |a, b| a <=> b } optional block not reqd
+    end
+
+    # explicitly provide 'processing.org' dist instance method
+    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
+      end
+      fail ArgumentError, 'takes 6 parameters'
+    end
+
+    # explicitly provide 'processing.org' constrain instance method
+    # to return a float:- amt, low and high need to be floats
+    def constrain(amt, low, high)
+      (low..high).clip(amt)
+    end
+
+    # Uses PImage class method under hood
+    def blend_color(c1, c2, mode)
+      Java::ProcessingCore::PImage::blendColor(c1, c2, mode)
+    end
+
+    # There's just so many functions in Processing,
+    # Here's a convenient way to look for them.
+    def find_method(method_name)
+      reg = Regexp.new("#{method_name}", true)
+      methods.sort.select { |meth| reg.match(meth) }
+    end
+
+    # Proxy over a list of Java declared fields that have the same name as
+    # some methods. Add to this list as needed.
+    def proxy_java_fields
+      fields = %w(sketchPath key frameRate frame mousePressed keyPressed)
+      methods  = fields.map { |field| java_class.declared_field(field) }
+      @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
+      int = @declared_fields['key'].value(java_self)
+      int < 256 ? int.chr : int
+    end
+
+    # Provide a convenient handle for the Java-space version of self.
+    def java_self
+      @java_self ||= to_java(Java::ProcessingCore::PApplet)
+    end
+
+    # Get the sketch path
+    def sketch_path
+      @declared_fields['sketchPath'].value(java_self)
+    end
+
+    # Fields that should be made accessible as under_scored.
+    define_method(:mouse_x) { mouseX }
+
+    define_method(:mouse_y) { mouseY }
+
+    define_method(:pmouse_x) { pmouseX }
+
+    define_method(:pmouse_y) { pmouseY }
+
+    define_method(:frame_count) { frameCount }
+
+    define_method(:mouse_button) { mouseButton }
+
+    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
+    end
+
+    # Writes an array of strings to a file, one line per string.
+    # This file is saved to the sketch's data folder
+    def save_strings(filename, strings)
+      saveStrings(filename, [strings].flatten.to_java(:String))
+    end
+
+    # frame_rate needs to support reading and writing
+    def frame_rate(fps = nil)
+      return @declared_fields['frameRate'].value(java_self) unless fps
+      super(fps)
+    end
+
+    # Is the mouse pressed for this frame?
+    def mouse_pressed?
+      @declared_fields['mousePressed'].value(java_self)
+    end
+
+    # Is a key pressed for this frame?
+    def key_pressed?
+      @declared_fields['keyPressed'].value(java_self)
+    end
+  end
+end

data/lib/jruby_art/helpers/camel_string.rb

@@ -0,0 +1,18 @@
+require 'forwardable'
+
+# Avoid the monkey patching of String for camelize
+class CamelString
+  extend Forwardable
+  def_delegators(:@string, *String.public_instance_methods(false))
+  def initialize(str = 'no_name')
+    @string = (str.length > 60) ? 'long_name' : str
+  end
+
+  def camelize(first_letter_in_uppercase = true)
+    if first_letter_in_uppercase
+      @string.gsub(/\/(.?)/) { '::' + $1.upcase }.gsub(/(^|_)(.)/) { $2.upcase }
+    else
+      @string[0] + camelize[1..-1]
+    end
+  end
+end

data/lib/jruby_art/helpers/numeric.rb

@@ -0,0 +1,9 @@
+class Numeric #:nodoc:
+  def degrees
+    self * 180 / Math::PI
+  end
+
+  def radians
+    self * Math::PI / 180
+  end
+end

data/lib/jruby_art/helpers/range.rb

@@ -0,0 +1,11 @@
+class Range #:nodoc:
+  def clip(n)
+    if cover?(n)
+      n
+    elsif n < min
+      min
+    else
+      max
+    end
+  end
+end

data/lib/jruby_art/helpers/string_extra.rb

@@ -0,0 +1,33 @@
+require 'forwardable'
+
+# Avoid the monkey patching of String for underscore/titleize/humanize
+class StringExtra
+  extend Forwardable
+  def_delegators(:@string, *String.public_instance_methods(false))
+  def initialize(str = 'no_name')
+    @string = (str.length > 60) ? 'long_name' : str
+  end
+
+  def titleize
+    gsub(/::/, '/')
+      .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+      .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+      .tr('-', '_')
+      .downcase
+      .gsub(/_id$/, '')
+      .gsub(/_/, ' ').capitalize
+      .gsub(/\b([a-z])/) { $1.capitalize }
+  end
+
+  def humanize
+    gsub(/_id$/, '').gsub(/_/, ' ').capitalize
+  end
+
+  def underscore
+    gsub(/::/, '/')
+      .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+      .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+      .tr('-', '_')
+      .downcase
+  end
+end

data/lib/jruby_art/parse.rb

@@ -0,0 +1,60 @@
+# -*- encoding : utf-8 -*-
+
+SKETCH_PATH ||= ARGV.shift
+SKETCH_ROOT ||= File.dirname(SKETCH_PATH)
+
+require_relative '../jruby_art'
+require_relative '../jruby_art/'
+require_relative '../jruby_art/helpers/string_extra'
+
+module Processing
+  # For use with "bare" sketches that don't want to define a class or methods
+  BARE_TEMPLATE = <<-EOS
+  require 'jruby_art'
+
+  class Sketch < %s
+    %s
+  end
+
+  Sketch.new(title: '%s')
+  EOS
+  
+  NAKED_TEMPLATE = <<-EOS
+  require 'jruby_art'
+
+  class Sketch < Processing::App
+
+    def setup
+      %s
+      no_loop
+    end
+  end
+
+  Sketch.new(title: '%s')
+  EOS
+
+  # This method is the common entry point to run a sketch, bare or complete.
+  def self.load_and_run_sketch
+    source = read_sketch_source
+    has_sketch = !source.match(/^[^#]*< Processing::App/).nil?
+    has_methods = !source.match(/^[^#]*(def\s+setup|def\s+draw)/).nil?    
+    return load File.join(SKETCH_ROOT, SKETCH_PATH) if has_sketch
+    title = StringExtra.new(File.basename(SKETCH_PATH).sub(/(\.rb)$/, '')).titleize
+    if has_methods
+      default = source.match(/P(2|3)D/)      
+      mode = default ? 'Processing::App' : 'Processing::AppGL'
+      code = format(BARE_TEMPLATE, mode, source, title)
+    else     
+      code = format(NAKED_TEMPLATE, source, title)
+    end
+    Object.class_eval code, SKETCH_PATH, -1
+  end
+
+  # Read in the sketch source code. Needs to work both online and offline.
+  def self.read_sketch_source
+    File.read(SKETCH_PATH)
+  end
+end
+
+Processing.load_and_run_sketch
+