processing.rb 1.1.1

data/lib/processing/system.rb

@@ -0,0 +1,57 @@
+# Provides the classes and methods for a Processing sketch
+module Processing
+  def self.load_library(name)
+    if load_jars(File.join(SketchRunner::SKETCH_LIBS_DIR, name, 'library')) ||
+       load_jars(File.join(SketchRunner::PROCESSING_DIR, name, 'library'))
+    else
+      fail "library not found -- #{name}"
+    end
+  end
+
+  def self.load_jars(dir)
+    is_success = false
+
+    if File.directory?(dir)
+      Dir.glob(File.join(dir, '*.jar')).each do |jar|
+        require jar
+        is_success = true
+        puts "jar file loaded -- #{File.basename(jar)}"
+      end
+
+      return true if is_success
+    end
+
+    false
+  end
+
+  def self.import_package(package, module_name)
+    code = "module #{module_name}; include_package '#{package}'; end"
+    Object::TOPLEVEL_BINDING.eval(code)
+  end
+
+  def self.sketch_path(path)
+    File.join(SketchRunner::SKETCH_DIR, path)
+  end
+
+  def self.start(sketch, opts = {})
+    title = opts[:title] || SketchRunner::SKETCH_NAME
+    topmost = opts[:topmost]
+    pos = opts[:pos]
+
+    PApplet.run_sketch([title], sketch)
+
+    if topmost
+      request = { command: :topmost, sketch: sketch }
+      SketchRunner.system_requests << request
+    end
+
+    if pos
+      request = { command: :pos, sketch: sketch, pos: pos }
+      SketchRunner.system_requests << request
+    end
+  end
+
+  def self.reload
+    SketchRunner.system_requests << { command: :reload }
+  end
+end

data/lib/sketch_runner/config.rb

@@ -0,0 +1,64 @@
+# Runs a sketch and reloads it when related files change
+module SketchRunner
+  VERSION = '1.1.1'
+
+  CONFIG_MTIME = File.stat(__FILE__).mtime
+
+  PACKAGE_ROOT = File.expand_path(File.join(File.dirname(__FILE__), '../..'))
+
+  APPDATA_ROOT = File.expand_path('~/.processing.rb')
+  APPDATA_CHECK_FILE = File.join(APPDATA_ROOT, '.complete')
+
+  JRUBY_URL = 'https://s3.amazonaws.com/jruby.org/downloads/9.0.0.0.pre1/jruby-complete-9.0.0.0.pre1.jar'
+  JRUBY_FILE = File.join(APPDATA_ROOT, 'jruby/jruby.jar')
+
+  if RUBY_PLATFORM == 'java'
+    BIT_SIZE = java.lang.System.getProperty('sun.arch.data.model') == '64' ?
+      64 : 32
+  else
+    require 'open3'
+    BIT_SIZE = Open3.capture3('java -version')[1].include?('64-Bit') ? 64 : 32
+  end
+
+  if RUBY_PLATFORM == 'java'
+    PLATFORM = :JAVA
+  elsif /darwin/ =~ RUBY_PLATFORM
+    PLATFORM = :MACOSX
+  elsif /cygwin|mswin|mingw|bccwin|wince|emx/ =~ RUBY_PLATFORM
+    PLATFORM = BIT_SIZE == 32 ? :WIN32 : :WIN64
+  else
+    PLATFORM = BIT_SIZE == 32 ? :LINUX32 : :LINUX64
+  end
+
+  PROCESSING_URL = {
+    MACOSX: 'http://download.processing.org/processing-2.2.1-macosx.zip',
+    WIN32: 'http://download.processing.org/processing-2.2.1-windows32.zip',
+    WIN64: 'http://download.processing.org/processing-2.2.1-windows64.zip',
+    LINUX32: 'http://download.processing.org/processing-2.2.1-linux32.tgz',
+    LINUX64: 'http://download.processing.org/processing-2.2.1-linux64.tgz'
+  }[PLATFORM]
+
+  if PLATFORM == :MACOSX
+    PROCESSING_CORE_PATH = 'Processing.app/Contents/Java/core'
+    PROCESSING_LIBS_PATH = 'Processing.app/Contents/Java/modes/java/libraries'
+  else
+    PROCESSING_CORE_PATH = 'processing-2.2.1/core'
+    PROCESSING_LIBS_PATH = 'processing-2.2.1/modes/java/libraries'
+  end
+
+  PROCESSING_DIR = File.join(APPDATA_ROOT, 'processing')
+  PROCESSING_ZIP_DIR = File.join(APPDATA_ROOT, 'processing-zip')
+  PROCESSING_ZIP_FILE = File.join(PROCESSING_ZIP_DIR, 'processing.zip')
+
+  EXAMPLES_SRC_DIR = File.join(PACKAGE_ROOT, 'examples')
+  EXAMPLES_DEST_DIR = File.expand_path('~/processingrb_examples')
+
+  LOAD_PATH = File.join(PACKAGE_ROOT, 'lib')
+  STARTUP_FILE = File.join(PACKAGE_ROOT, 'lib/sketch_runner/runner.rb')
+
+  SKETCH_FILE = File.expand_path(ARGV.length > 0 ? ARGV[0] : '')
+  SKETCH_DIR, SKETCH_NAME = File.split(SKETCH_FILE)
+  SKETCH_LIBS_DIR = File.join(SKETCH_DIR, 'libraries')
+
+  WATCH_INTERVAL = 0.1
+end

data/lib/sketch_runner/launch.rb

@@ -0,0 +1,11 @@
+# Runs a sketch and reloads it when related files change
+module SketchRunner
+  def self.launch
+    jruby_opts = "-I#{LOAD_PATH}"
+    jruby_args = "#{STARTUP_FILE} #{$PROGRAM_NAME} #{ARGV.join(' ')}"
+    exec("java -jar #{JRUBY_FILE} #{jruby_opts} #{jruby_args}")
+  end
+  private_class_method :launch
+
+  launch
+end

data/lib/sketch_runner/runner.rb

@@ -0,0 +1,108 @@
+require 'find'
+require_relative 'config'
+
+# Runs a sketch and reloads it when related files change
+module SketchRunner
+  class << self
+    def system_requests
+      @system_requests ||= []
+    end
+
+    def sketch_instances
+      @sketch_instances ||= []
+    end
+  end
+
+  def self.start
+    $PROGRAM_NAME = ARGV.shift
+
+    jars = File.join(PROCESSING_DIR, 'core/library/*.jar')
+    Dir.glob(jars).each { |jar| require jar }
+
+    initial_constants = Object.constants
+    initial_features = $LOADED_FEATURES.dup
+
+    loop do
+      puts '****** START SKETCH ******'
+
+      run_sketch
+      watch_file_changes
+      restore_environment(initial_constants, initial_features)
+    end
+  end
+  private_class_method :start
+
+  def self.run_sketch
+    Thread.new do
+      begin
+        Object::TOPLEVEL_BINDING.eval(File.read(SKETCH_FILE), SKETCH_FILE)
+      rescue Exception => e
+        puts e
+      end
+    end
+  end
+  private_class_method :run_sketch
+
+  def self.watch_file_changes
+    execute_time = Time.now
+
+    catch :break_loop do
+      loop do
+        system_requests.each do |request|
+          system_requests.delete(request) if respond_to_request(request)
+        end
+
+        Find.find(SKETCH_DIR) do |file|
+          is_ruby = FileTest.file?(file) && File.extname(file) == '.rb'
+          throw :break_loop if is_ruby && File.mtime(file) > execute_time
+        end
+
+        sleep(WATCH_INTERVAL)
+      end
+    end
+  end
+  private_class_method :watch_file_changes
+
+  def self.respond_to_request(request)
+    case request[:command]
+    when :topmost
+      sketch = request[:sketch]
+      sketch.frame.set_always_on_top(true)
+
+      return sketch.frame.is_always_on_top
+    when :pos
+      sketch = request[:sketch]
+      pos_x, pos_y = request[:pos]
+      sketch.frame.set_location(pos_x, pos_y)
+
+      cur_pos = sketch.frame.get_location
+      return cur_pos.x == pos_x && cur_pos.y == pos_y
+    when :reload
+      throw :break_loop
+    end
+  end
+  private_class_method :respond_to_request
+
+  def self.restore_environment(initial_constants, initial_features)
+    sketch_instances.each do |sketch|
+      sketch.frame.dispose
+      sketch.dispose
+    end
+
+    sketch_instances.clear
+    system_requests.clear
+
+    added_constants = Object.constants - initial_constants
+    added_constants.each do |constant|
+      Object.class_eval { remove_const constant }
+    end
+
+    added_features = $LOADED_FEATURES - initial_features
+    added_features.each { |feature| $LOADED_FEATURES.delete(feature) }
+
+    java.lang.System.gc
+  end
+  private_class_method :restore_environment
+
+  start
+end

data/lib/sketch_runner/setup.rb

@@ -0,0 +1,85 @@
+require 'fileutils'
+require 'open_uri_redirections'
+require 'openssl'
+require 'zip'
+
+# Runs a sketch and reloads it when related files change
+module SketchRunner
+  def self.setup
+    puts "Processing.rb #{VERSION}"
+
+    return if File.exist?(APPDATA_CHECK_FILE) &&
+              File.stat(APPDATA_CHECK_FILE).mtime > CONFIG_MTIME
+
+    FileUtils.remove_dir(APPDATA_ROOT, true)
+
+    puts 'JRuby and Processing will be downloaded just one time.'
+    puts 'Please input a proxy if necessary, otherwise just press Enter.'
+    print '(e.g. http://proxy.hostname:port): '
+    proxy = $stdin.gets.chomp
+    proxy = nil if proxy == ''
+
+    download(JRUBY_URL, JRUBY_FILE, proxy)
+
+    download(PROCESSING_URL, PROCESSING_ZIP_FILE, proxy)
+    unzip(PROCESSING_ZIP_FILE, PROCESSING_ZIP_DIR)
+
+    FileUtils.mkdir_p(PROCESSING_DIR)
+    processing_core_dir = File.join(PROCESSING_ZIP_DIR, PROCESSING_CORE_PATH)
+    FileUtils.cp_r(processing_core_dir, PROCESSING_DIR)
+
+    processing_libs_dir = File.join(PROCESSING_ZIP_DIR, PROCESSING_LIBS_PATH)
+    Dir.glob(File.join(processing_libs_dir, '*')).each do |dir|
+      FileUtils.cp_r(dir, PROCESSING_DIR)
+    end
+
+    FileUtils.remove_dir(PROCESSING_ZIP_DIR, true)
+
+    FileUtils.touch(APPDATA_CHECK_FILE)
+  end
+  private_class_method :setup
+
+  def self.download(url, file, proxy)
+    print "download #{File.basename(url)} ... "
+
+    FileUtils.mkdir_p(File.dirname(file))
+
+    open(file, 'wb') do |output|
+      begin
+        open(
+          url,
+          proxy: proxy,
+          allow_redirections: :safe,
+          ssl_verify_mode: OpenSSL::SSL::VERIFY_NONE
+        ) do |data|
+          output.write(data.read)
+        end
+      rescue StandardError
+        puts "\nunable to download file -- #{url}"
+        exit false
+      end
+    end
+
+    puts 'done'
+  end
+  private_class_method :download
+
+  def self.unzip(file, dest_dir)
+    print "unzip #{File.basename(file)} ... "
+
+    Zip::File.open(file) do |zip|
+      zip.each do |entry|
+        dest_file = File.join(dest_dir, entry.name)
+
+        unless File.basename(dest_file).start_with?('._')
+          entry.extract(dest_file)
+        end
+      end
+    end
+
+    puts 'done'
+  end
+  private_class_method :unzip
+
+  setup
+end

data/processing.rb.gemspec

@@ -0,0 +1,19 @@
+require_relative 'lib/sketch_runner/config'
+
+Gem::Specification.new do |spec|
+  spec.name         = 'processing.rb'
+  spec.version      = SketchRunner::VERSION
+  spec.author       = 'Takashi Kitao'
+  spec.email        = 'takashi.kitao@gmail.com'
+  spec.summary      = 'A simple Processing sketch runner for Ruby'
+  spec.description  =
+    'Processing.rb runs a Processing sketch written in Ruby, ' \
+    'and reloads it automatically when files in the same directory change.'
+  spec.homepage     = 'https://github.com/kitao/processing.rb'
+  spec.license      = 'MIT'
+  spec.files        = `git ls-files -z`.split("\x0")
+  spec.executables  = ['setup_processingrb_examples']
+  spec.requirements = ['java >= 1.8.0_40']
+  spec.add_runtime_dependency 'open_uri_redirections', '~> 0.2.1'
+  spec.add_runtime_dependency 'rubyzip', '~> 1.1.7'
+end

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: processing.rb
+version: !ruby/object:Gem::Version
+  version: 1.1.1
+platform: ruby
+authors:
+- Takashi Kitao
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-04-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: open_uri_redirections
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.2.1
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 1.1.7
+description: Processing.rb runs a Processing sketch written in Ruby, and reloads it
+  automatically when files in the same directory change.
+email: takashi.kitao@gmail.com
+executables:
+- setup_processingrb_examples
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- CHANGELOG.md
+- LICENSE
+- README.ja.md
+- README.md
+- bin/setup_processingrb_examples
+- examples/01_simple_sketch.rb
+- examples/02_input_handling.rb
+- examples/03_multi_file.rb
+- examples/04_builtin_library.rb
+- examples/05_external_library.rb
+- examples/data/cat.mov
+- examples/data/dog.mov
+- examples/libraries/handy/library.properties
+- examples/libraries/handy/library/handy.jar
+- examples/modules/moving_box.rb
+- examples/modules/textured_cube.rb
+- examples/screenshots/01_simple_sketch.png
+- examples/screenshots/02_input_handling.png
+- examples/screenshots/03_multi_file.png
+- examples/screenshots/04_builtin_library.png
+- examples/screenshots/05_external_library.png
+- lib/processing.rb
+- lib/processing/sketch_base.rb
+- lib/processing/system.rb
+- lib/sketch_runner/config.rb
+- lib/sketch_runner/launch.rb
+- lib/sketch_runner/runner.rb
+- lib/sketch_runner/setup.rb
+- processing.rb.gemspec
+homepage: https://github.com/kitao/processing.rb
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements:
+- java >= 1.8.0_40
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: A simple Processing sketch runner for Ruby
+test_files: []