jruby_art 0.2.6.pre → 0.3.0.pre

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 186cf1166260ed477d29a53e4d6af5982ec61320
-  data.tar.gz: 778ff0c076f4fc7a5cae5e297713ee2154eadafd
+  metadata.gz: e2f18112ba5aae2c2dfdd271945d91c157242dce
+  data.tar.gz: c917b6420da85b1e4c45b71de2a84b57dbc2712b
 SHA512:
-  metadata.gz: 5501b44349aefdbedd0531db69d1e539e85f2da546a0777da584b159540b03909e960ae6b433bbf5639dc3ba2795b9ac173837657a8f25b685af4735dfd0dcf0
-  data.tar.gz: 6a331e4710e2f8185e2cc535959e033b14906e35561d4625040fd43ab01523bdd5f84a0db04cd4f9bc39b1e4980ce65b2e69ac21ac78da1d721e313c9d43acd0
+  metadata.gz: 094e0e81bc65c61753fd6fb6b2c5bb2260496effb480670e6d8c75d818f36e0410abdba62899e7dcbc85f7d460cedd82e2696ac708c15a47450dc161aaddc430
+  data.tar.gz: 5c673af5d1e65b84327be0fc5983cfea3d4ce4a0963e0082230b8755bb12aa4caf1fae516f4e6f01dc2bdf84f4c7f5df71d5d6789890334079cfd15c004379ca

data/bin/k9

@@ -2,9 +2,9 @@
 
 file = __FILE__
 if test(?l, file)
-  require 'pathname'
+  require "pathname"
   file = Pathname.new(file).realpath
 end
 
-require File.expand_path(File.dirname(file) + '/../lib/jruby_art')
+require File.expand_path(File.dirname(file) + "/../lib/jruby_art")
 Processing::Runner.execute

data/lib/jruby_art.rb

@@ -1,30 +1,25 @@
-require 'rbconfig'
-
-VERBOSE = true
-
-unless defined? K9_ROOT
+# Ruby-Processing is for Code Art.
+# Send suggestions, ideas, and hate-mail to mamba2928 [at] gmail.com
+# Also, send samples and libraries.
+unless defined? RP5_ROOT
   $LOAD_PATH << File.expand_path(File.dirname(__FILE__))
-  K9_ROOT = File.expand_path(File.dirname(__FILE__) + '/../')
+  RP5_ROOT = File.expand_path(File.dirname(__FILE__) + '/../')
 end
 
-# guard prevents issues with mri ruby when using creator
-if RUBY_PLATFORM == 'java'
-  working_directory = File.join(File.dirname(__FILE__))
-  $LOAD_PATH << working_directory unless $LOAD_PATH.include?(working_directory)
-  Dir[File.join(working_directory, '*.jar')].each do |jar|
-    # require_relative jar unless jar =~ /native/ (breaks netbeans)
-    require jar unless jar =~ /native/
-  end
-  Java::ProcessingFastmath::DeglutLibrary.new.load(JRuby.runtime, false)
-  Java::ProcessingVecmathVec2::Vec2Library.new.load(JRuby.runtime, false)
-  Java::ProcessingVecmathVec3::Vec3Library.new.load(JRuby.runtime, false)
-  AppRender = Java::ProcessingVecmath::AppRender
-  ShapeRender = Java::ProcessingVecmath::ShapeRender
-  require 'jruby_art/app'
-  require 'jruby_art/helper_methods'
-end
+SKETCH_ROOT ||= Dir.pwd
 
 require 'jruby_art/version'
 require 'jruby_art/helpers/numeric'
 require 'jruby_art/helpers/range'
-require 'jruby_art/runner'
+
+# The top-level namespace, a home for all Ruby-Processing classes.
+module Processing
+
+  # Autoload a number of path/constants that we may end up using.
+  # mri ruby does not understand ** require 'java' ** and we may otherwise call
+  # it from mri ruby without lazy path loading of autoload
+  # NB: autoload was slated for possible removal by ruby-2.2 never happened
+  autoload :App,                  'jruby_art/app'
+  autoload :Runner,               'jruby_art/runner'
+  autoload :Watcher,              'jruby_art/runners/watch'
+end

data/lib/jruby_art/app.rb

@@ -1,69 +1,25 @@
-require_relative 'helper_methods'
-require_relative 'library_loader'
-
-# The Processing module is a wrapper for JRubyArt
-# Author:: Martin Prout (extends / re-implements ruby-processing)
+require 'java'
+require_relative '../rpextras'
+require_relative '../jruby_art/helper_methods'
+require_relative '../jruby_art/helpers/string_extra'
+require_relative '../jruby_art/library_loader'
+require_relative '../jruby_art/config'
+
+# A wrapper module for the processing App
 module Processing
-  include_package 'processing.core' # imports the processing.core package.
-  include_package 'processing.event'
-  # This class is the base class the user should inherit from when making
-  # their own sketch.
-  #
-  # i.e.
-  #
-  # class MySketch < Processing::App
-  #
-  #   def draw
-  #     background rand(255)
-  #   end
-  #
-  # end
-  #
-  module Common
-    # This method provides the possibility of adding and using
-    # new runtime options in sketches no need to re-define initialize
-    #
-    def post_initialize(_opts = {})
-      nil
-    end
-
-    # This method configures the sketch title and and presentation mode.
-    #
-    def configure_sketch
-      presentation_mode
-      sketch_title
-    end
-
-    # This method sets the sketch presentation mode.
-    #
-    def presentation_mode
-      return unless opts[:fullscreen]
-      args << '--full-screen'
-      args << "--bgcolor=#{opts[:bgcolor]}" if opts[:bgcolor]
-    end
+  # Include some core processing classes that we'd like to use:
+  include_package 'processing.core'
+  # Load vecmath and fastmath modules
+  Java::ProcessingVecmathArcball::ArcballLibrary.new.load(JRuby.runtime, false)
+  Java::ProcessingVecmathVec2::Vec2Library.new.load(JRuby.runtime, false)
+  Java::ProcessingVecmathVec3::Vec3Library.new.load(JRuby.runtime, false)
+  Java::ProcessingFastmath::DeglutLibrary.new.load(JRuby.runtime, false)
+  AppRender ||= Java::ProcessingVecmath::AppRender
+  ShapeRender ||= Java::ProcessingVecmath::ShapeRender
 
-    # This method is the main draw loop of the sketch. This is usually
-    # overridden by the user.
-    #
-    def draw
-      nil
-    end
-
-    # This method runs the processing sketch.
-    #
-    def run_sketch
-      PApplet.run_sketch(args.to_java(:string), self)
-    end
-
-    # This method sets the sketch title.
-    #
-    def sketch_title
-      args << opts.fetch(:title, 'Sketch')
-    end
-  end
   # Watch the definition of these methods, to make sure
   # that Processing is able to call them during events.
-  METHODS_TO_ALIAS = {
+  METHODS_TO_ALIAS ||= {
     mouse_pressed: :mousePressed,
     mouse_dragged: :mouseDragged,
     mouse_clicked: :mouseClicked,
@@ -73,11 +29,28 @@ module Processing
     key_released: :keyReleased,
     key_typed: :keyTyped
   }
-
-  # This class is for default (Java2D) sketches only
+  # All sketches extend this class
   class App < PApplet
-    include Math, Common, HelperMethods
-    attr_reader :title, :args, :opts
+    include Math
+    include HelperMethods
+    # Alias some methods for familiarity for Shoes coders.
+    # surface replaces :frame, but needs field_reader for access
+    alias_method :oval, :ellipse
+    alias_method :stroke_width, :stroke_weight
+    alias_method :rgb, :color
+    alias_method :gray, :color
+    field_reader :surface
+
+    def sketch_class
+      self.class.sketch_class
+    end
+
+    # Keep track of what inherits from the Processing::App, because we're
+    # going to want to instantiate one.
+    def self.inherited(subclass)
+      super(subclass)
+      @sketch_class = subclass
+    end
 
     class << self
       # Handy getters and setters on the class go here:
@@ -85,10 +58,22 @@ module Processing
 
       def load_libraries(*args)
         library_loader ||= LibraryLoader.new
-        library_loader.load_libraries(*args)
+        library_loader.load_library(*args)
       end
       alias_method :load_library, :load_libraries
 
+      def library_loaded?(library_name)
+        library_loader.library_loaded?(library_name)
+      end
+
+      def load_ruby_library(*args)
+        library_loader.load_ruby_library(*args)
+      end
+
+      def load_java_library(*args)
+        library_loader.load_java_library(*args)
+      end
+
       # When certain special methods get added to the sketch, we need to let
       # Processing call them by their expected Java names.
       def method_added(method_name) #:nodoc:
@@ -97,84 +82,86 @@ module Processing
       end
     end
 
-    def sketch_class
-      self.class.sketch_class
+    def library_loaded?(library_name)
+      self.class.library_loaded?(library_name)
     end
 
-    # App should be instantiated with an optional list of opts
-    # and array of args.
-    #
-    # App.new(title: 'My Simple App', fullscreen: true)
-    #
-    def initialize(opts = {}, args = [])
+    # Since processing-3.0 you should prefer setting the sketch width and
+    # height and renderer using the size method in the settings loop of the
+    # sketch (as with vanilla processing) but is hidden see created java.
+    # Options are no longer relevant, define post_initialize method to use
+    # custom options (see Sandi Metz POODR)
+
+    def initialize(options = {})
       super()
-      proxy_java_fields
-      post_initialize(opts)
-      @args = args
-      @opts = opts
+      post_initialize(options) # for anyone wishing to pass options
       $app = self
-      configure_sketch
+      proxy_java_fields
+      mix_proxy_into_inner_classes
+      java.lang.Thread.default_uncaught_exception_handler = proc do |_thread_, exception|
+        puts(exception.class.to_s)
+        puts(exception.message)
+        puts(exception.backtrace.map { |trace| "\t#{trace}" })
+        close
+      end
+      # NB: this is the processing runSketch() method as used by processing.py
       run_sketch
     end
 
-    # This method provides the default setup for the sketch. It can
-    # be overridden by the user for finer grained control.
-    #
-    def setup
-      size(width, height)
+    def size(*args)
+      w, h, mode = *args
+      @width ||= w
+      @height ||= h
+      @render_mode ||= mode
+      import_opengl if /opengl/ =~ mode
+      super(*args)
     end
-  end
 
-  # This class is for opengl sketches (P2D and P3D)
-  class AppGL < PApplet
-    include Math, Processing, Common
-    include_package 'processing.opengl' # imports the processing.opengl package.
-    include HelperMethods
-    Java::ProcessingVecmathArcball::ArcballLibrary.new.load(JRuby.runtime, false)
-    attr_reader :title, :args, :opts
-
-    # App should be instantiated with an optional list of opts
-    # and array of args.
-    #
-    # App.new(title: 'My Simple App', fullscreen: true)
-    #
-    def initialize(opts = {}, args = [])
-      super()
-      proxy_java_fields
-      post_initialize(opts)
-      @args = args
-      @opts = opts
-      $app = self
-      configure_sketch
-      run_sketch
+    def sketch_title(title)
+      surface.setTitle(title)
     end
 
-    # This method provides the default setup for the sketch. It can
-    # be overridden by the user for finer grained control.
-    #
-    def setup
-      size(width, height, mode = P3D)
-      fail unless /opengl/ =~ mode
+    def post_initialize(_args)
+      nil
     end
 
-    class << self
-      # Handy getters and setters on the class go here:
-      attr_accessor :sketch_class, :library_loader
+    # Close and shutter a running sketch. But don't exit.
+    # @HACK seems to work with watch until we find a better
+    # way of disposing of sketch window...
+    def close
+      control_panel.remove if respond_to?(:control_panel)
+      surface.stopThread
+      surface.setVisible(false) if surface.isStopped()
+      dispose
+    end
 
-      def load_libraries(*args)
-        library_loader ||= LibraryLoader.new
-        library_loader.load_libraries(*args)
+    def exit
+      control_panel.remove if respond_to?(:control_panel)
+      super()
+    end
+
+    private
+
+    # Mix the Processing::Proxy into any inner classes defined for the
+    # sketch, attempting to mimic the behavior of Java's inner classes.
+    def mix_proxy_into_inner_classes
+      klass = Processing::App.sketch_class
+      klass.constants.each do |name|
+        const = klass.const_get name
+        next if const.class != Class || const.to_s.match(/^Java::/)
+        const.class_eval 'include Processing::Proxy'
       end
-      alias_method :load_library, :load_libraries
+    end
 
-      # When certain special methods get added to the sketch, we need to let
-      # Processing call them by their expected Java names.
-      def method_added(method_name) #:nodoc:
-        return unless METHODS_TO_ALIAS.key?(method_name)
-        alias_method METHODS_TO_ALIAS[method_name], method_name
+    def import_opengl
+      # Include processing opengl classes that we'd like to use:
+      %w(FontTexture FrameBuffer LinePath LineStroker PGL
+      PGraphics2D PGraphics3D PGraphicsOpenGL PShader
+      PShapeOpenGL Texture).each do |klass|
+        java_import format('processing.opengl.%s', klass)
       end
     end
-  end
+  end # Processing::App
 
   # Importing PConstants to access to processing constants,
   # to keep namespace clean use PConstants::TRIANGLE (for example)
@@ -183,11 +170,12 @@ module Processing
   # @HACK you should consider using 'forwardable' to avoid this
   # egregious hack...
   module Proxy
+    include Math
     java_import 'processing.core.PConstants'
- 
+
     def method_missing(name, *args)
       return $app.send(name, *args) if $app && $app.respond_to?(name)
       super
     end
-  end
-end
+  end # Processing::Proxy
+end # Processing

data/lib/jruby_art/config.rb

@@ -1,16 +1,14 @@
-require 'yaml'
-# The Processing module is a wrapper for JRubyArt
-# Author:: Martin Prout (extends / re-implements ruby-processing)
+require 'psych'
+
+# The wrapper module
 module Processing
   unless defined? RP_CONFIG
+    config_path = '~/.jruby_art/config.yml'
     begin
-      CONFIG_FILE_PATH = File.expand_path('~/.jruby_art/config.yml')
-      RP_CONFIG = YAML.load_file(CONFIG_FILE_PATH)
+      CONFIG_FILE_PATH = File.expand_path(config_path)
+      RP_CONFIG = (Psych.load_file(CONFIG_FILE_PATH))
     rescue
-      warn('WARNING: you need to set PROCESSING_ROOT in ~/.jruby_art/config.yml')
+      warn(format('WARN: you need to set PROCESSING_ROOT in %s', config_path))
     end
   end
 end
-
-
-

data/lib/jruby_art/creators/creator.rb

@@ -0,0 +1,189 @@
+BASIC = <<-CODE
+def setup
+  sketch_title '%s'
+end
+
+def draw
+
+end
+
+def settings
+  size %s, %s, FX2D
+  # smooth # here
+end
+
+CODE
+
+BASIC_MODE = <<-CODE
+def setup
+  sketch_title '%s'
+end
+
+def draw
+
+end
+
+def settings
+  size %s, %s, %s
+  # smooth # here
+end
+
+CODE
+
+CLASS_BASIC = <<-CODE
+class %s < Processing::App
+  def setup
+    sketch_title '%s'
+  end
+
+  def draw
+
+  end
+
+  def settings
+    size %s, %s, FX2D
+    # smooth # here
+  end
+end
+CODE
+
+CLASS_MODE = <<-CODE
+class %s < Processing::App
+  def setup
+    sketch_title '%s'
+  end
+
+  def draw
+
+  end
+
+  def settings
+    size %s, %s, %s
+    # smooth # here
+  end
+end
+CODE
+
+INNER = <<-CODE
+class %s
+  include Processing::Proxy
+
+end
+CODE
+
+# processing wrapper module
+module Processing
+  require_relative '../helpers/string_extra'
+  require_relative '../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 !FileTest.exist?(path) && !FileTest.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> <mode>
+      mode can be P2D / P3D.
+      Use    --wrap for a sketch wrapped as a class
+      Use    --inner to generated a ruby version of 'java' Inner class
+      Examples: k9 create app 800 600
+      k9 create app 800 600 p3d --wrap
+      k9 create inner_class --inner
+
+      USAGE
+    end
+  end
+
+  # This class creates bare sketches, with an optional render mode
+  class BasicSketch < Creator
+    # Create a blank sketch, given a path.
+    def basic_template
+      format(BASIC, @title, @width, @height)
+    end
+
+    def basic_template_mode
+      format(BASIC_MODE, @title, @width, @height, @mode)
+    end
+
+    def create!(path, args)
+      return usage if /\?/ =~ path || /--help/ =~ path
+      # Check to make sure that the main file doesn't exist already
+      already_exist(path)
+      main_file = File.basename(path, '.rb') # allow uneeded extension input
+      writer = SketchWriter.new(main_file)
+      @title = StringExtra.new(main_file).titleize
+      @width = args[0]
+      @height = args[1]
+      @mode = args[2].upcase unless args[2].nil?
+      template = @mode.nil? ? basic_template : basic_template_mode
+      writer.save(template)
+    end
+  end
+
+  # This class creates class wrapped sketches, with an optional render mode
+  class ClassSketch < Creator
+    def class_template
+      format(CLASS_BASIC, @name, @title, @width, @height)
+    end
+
+    def class_template_mode
+      format(CLASS_MODE, @name, @title, @width, @height, @mode)
+    end
+    # Create a class wrapped 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
+
+  # This class creates a pseudo 'java inner class' of the sketch
+  class Inner < Creator
+    def inner_class_template
+      format(INNER, @name)
+    end
+    # Create a pseudo inner class, 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 = main_file.camelize
+      writer = SketchWriter.new(main_file)
+      template = inner_class_template
+      writer.save(template)
+    end
+  end
+end