picrate 1.3.0-java → 2.1.2-java

data/test/color_group_test.rb

@@ -9,21 +9,21 @@ java_import Java::Monkstone::ColorUtil
 Dir.chdir(File.dirname(__FILE__))
 
 PALETTE = %w[#FFFFFF #FF0000 #0000FF].freeze
-COLORS = [16777215, 16711680, 255].to_java(:int)
+COLORS = [16_777_215, 16_711_680, 255].to_java(:int)
 
 class ColorGroupTest < Minitest::Test
   def test_new
     group = ColorGroup.new(COLORS)
-    assert group.kind_of? ColorGroup
+    assert group.is_a? ColorGroup
   end
 
   def test_web_array
     group = ColorGroup.from_web_array(PALETTE)
-    assert group.kind_of? ColorGroup
+    assert group.is_a? ColorGroup
   end
 
   def test_ruby_string
-    p5array = [16777215, 16711680, 255]
+    p5array = [16_777_215, 16_711_680, 255]
     group = ColorGroup.new(COLORS)
     code_string = "%w[#FFFFFF #FF0000 #0000FF]\n"
     result = group.ruby_code

data/test/deglut_spec_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require_relative 'test_helper'
 
 Dir.chdir(File.dirname(__FILE__))

data/test/helper_methods_test.rb

@@ -10,40 +10,68 @@ include MathTool
 Dir.chdir(File.dirname(__FILE__))
 
 class HelperMethodsTest < Minitest::Test
-
- ARRAY = %w(albatross dog horse)
- def test_hex_color
+  ARRAY = %w[albatross dog horse].freeze
+  def test_hex_color
     col_double = 0.5
     hexcolor = 0xFFCC6600
     dodgy_hexstring = '*56666'
     hexstring = '#CC6600'
     assert hex_color(col_double) == 0.5, 'double as a color'
-    assert hex_color(hexcolor) == -3381760, 'hexadecimal fixnum color'
-    assert hex_color(hexstring) == -3381760, 'hexadecimal string color'
+    assert hex_color(hexcolor) == -3_381_760, 'hexadecimal fixnum color'
+    assert hex_color(hexstring) == -3_381_760, 'hexadecimal string color'
     assert_raises(StandardError, 'Dodgy Hexstring') do
       hex_color(dodgy_hexstring)
     end
     assert_raises(StandardError, 'Dodgy Color Conversion') do
       hex_color([])
     end
-  end
+   end
 
   def test_dist
-    ax, ay, bx, by = 0, 0, 1.0, 1.0
+    ax = 0
+    ay = 0
+    bx = 1.0
+    by = 1.0
     assert_in_epsilon(dist(ax, ay, bx, by), Math.sqrt(2), epsilon = 0.0001, msg = '2D distance')
     by = 0.0
     assert_in_epsilon(dist(ax, ay, bx, by), 1.0, epsilon = 0.0001, msg = 'when y dimension is zero')
-    ax, ay, bx, by = 0, 0, 0.0, 0.0
+    ax = 0
+    ay = 0
+    bx = 0.0
+    by = 0.0
     assert_in_epsilon(dist(ax, ay, bx, by), 0.0, epsilon = 0.0001, msg = 'when x and y dimension are zero')
-    ax, ay, bx, by = 1, 1, -2.0, -3.0
+    ax = 1
+    ay = 1
+    bx = -2.0
+    by = -3.0
     assert_in_epsilon(dist(ax, ay, bx, by), 5.0, epsilon = 0.0001, msg = 'classic triangle dimensions')
-    ax, ay, bx, by, cx, cy = -1, -1, 100, 2.0, 3.0, 100
+    ax = -1
+    ay = -1
+    bx = 100
+    by = 2.0
+    cx = 3.0
+    cy = 100
     assert_in_epsilon(dist(ax, ay, bx, by, cx, cy), 5.0, epsilon = 0.0001, msg = 'classic triangle dimensions')
-    ax, ay, bx, by, cx, cy = 0, 0, -1.0, -1.0, 0, 0
+    ax = 0
+    ay = 0
+    bx = -1.0
+    by = -1.0
+    cx = 0
+    cy = 0
     assert_in_epsilon(dist(ax, ay, bx, by, cx, cy), Math.sqrt(2), epsilon = 0.0001, msg = '2D distance')
-    ax, ay, bx, by, cx, cy = 0, 0, 0.0, 0.0, 0, 0
+    ax = 0
+    ay = 0
+    bx = 0.0
+    by = 0.0
+    cx = 0
+    cy = 0
     assert_in_epsilon(dist(ax, ay, bx, by, cx, cy), 0.0)
-    ax, ay, bx, by, cx, cy = 0, 0, 1.0, 0.0, 0, 0
+    ax = 0
+    ay = 0
+    bx = 1.0
+    by = 0.0
+    cx = 0
+    cy = 0
     assert_in_epsilon(dist(ax, ay, bx, by, cx, cy), 1.0, epsilon = 0.0001, msg = 'when x and z dimension are zero')
   end
 

data/test/math_tool_test.rb

@@ -1,73 +1,82 @@
+# frozen_string_literal: true
+
 require_relative 'test_helper'
 
 Java::Monkstone::PicrateLibrary.new.load(JRuby.runtime, false)
 
 # include Processing::HelperMethods
 
-
 Dir.chdir(File.dirname(__FILE__))
-
-class MathToolTest < Minitest::Test
- include MathTool
- def test_map1d
+# Test processing map functions
+class ProcessingMapTest < Minitest::Test
+  include MathTool
+  def test_map1d
     x = [0, 5, 7.5, 10]
     range1 = (0..10)
     range2 = (100..1)
     range3 = (0..10)
     range4 = (5..105)
-    assert_in_delta(map1d(x[0], range1, range2), 100, delta = 0.00001, msg = 'map to first')
-    assert_in_delta(map1d(x[1], range1, range2), 50.5, delta = 0.00001, msg = 'map to reversed intermediate')
-    assert_in_delta(map1d(x[2], range3, range4), 80.0, delta = 0.00001, msg = 'map to intermediate')
-    assert_in_delta(map1d(x[3], range1, range2), 1, delta = 0.00001, msg = 'map to last')
-  end
+    assert_in_delta(map1d(x[0], range1, range2), 100, 0.00001, 'map to first')
+    assert_in_delta(map1d(x[1], range1, range2), 50.5, 0.00001, 'map to reversed intermediate')
+    assert_in_delta(map1d(x[2], range3, range4), 80.0, 0.00001, 'map to intermediate')
+    assert_in_delta(map1d(x[3], range1, range2), 1, 0.00001, 'map to last')
+   end
 
-  def test_p5map # as map1d except not using range input
+  # as map1d except not using range input
+  def test_p5map
     x = [0, 5, 7.5, 10]
     range1 = (0..10)
     range2 = (100..1)
     range3 = (0..10)
     range4 = (5..105)
-    assert_in_delta(p5map(x[0], range1.first, range1.last, range2.first, range2.last), 100, delta = 0.00001)
-    assert_in_delta(p5map(x[1], range1.first, range1.last, range2.first, range2.last), 50.5, delta = 0.00001)
-    assert_in_delta(p5map(x[2], range3.first, range3.last, range4.first, range4.last), 80.0, delta = 0.00001)
-    assert_in_delta(p5map(x[3], range1.first, range1.last, range2.first, range2.last), 1, delta = 0.00001)
+    assert_in_delta(p5map(x[0], range1.first, range1.last, range2.first, range2.last), 100, 0.00001)
+    assert_in_delta(p5map(x[1], range1.first, range1.last, range2.first, range2.last), 50.5, 0.00001)
+    assert_in_delta(p5map(x[2], range3.first, range3.last, range4.first, range4.last), 80.0, 0.00001)
+    assert_in_delta(p5map(x[3], range1.first, range1.last, range2.first, range2.last), 1, 0.00001)
   end
 
   def test_norm
     x = [10, 140, 210]
-    start0, last0 = 30, 200
-    start_int, last_int = 0, 200
-    assert_in_delta(norm(x[0], start0, last0), -0.11764705882352941, delta = 0.00001, msg = 'unclamped map')
-    assert_in_delta(norm(x[1], start_int, last_int), 0.7, delta = 0.00001, msg = 'map to intermediate')
-    assert_in_delta(norm(x[2], start_int, last_int), 1.05, delta = 0.00001, msg = 'unclamped map')
+    start0 = 30
+    last0 = 200
+    start_int = 0
+    last_int = 200
+    assert_in_delta(norm(x[0], start0, last0), -0.11764705882352941, 0.00001, 'unclamped map')
+    assert_in_delta(norm(x[1], start_int, last_int), 0.7, 0.00001, 'map to intermediate')
+    assert_in_delta(norm(x[2], start_int, last_int), 1.05, 0.00001, 'unclamped map')
   end
 
   def test_norm_strict
     x = [10, 140, 210]
-    assert_in_delta(norm_strict(x[2], x[0], x[1]), 1.0, delta = 0.00001, msg = 'clamped map to 0..1.0')
-    assert_in_delta(norm_strict(x[2], x[1], x[0]), 0.0, delta = 0.00001, msg = 'clamped map to 0..1.0')
-    assert_in_delta(norm_strict(x[1], x[0], x[2]), 0.65, delta = 0.00001, msg = 'clamped map to 0..1.0')
+    assert_in_delta(norm_strict(x[2], x[0], x[1]), 1.0, 0.00001, 'clamped map to 0..1.0')
+    assert_in_delta(norm_strict(x[2], x[1], x[0]), 0.0, 0.00001, 'clamped map to 0..1.0')
+    assert_in_delta(norm_strict(x[1], x[0], x[2]), 0.65, 0.00001, 'clamped map to 0..1.0')
   end
 
-  def test_lerp # behaviour is deliberately different to processing which is unclamped
+  # behaviour is deliberately different to processing which is unclamped
+  def test_lerp
     x = [0.5, 0.8, 2.0]
-    start0, last0 = 300, 200
-    start_int, last_int = 0, 200
-    assert_in_delta(lerp(start0, last0, x[0]), 250, delta = 0.00001, msg = 'produces a intermediate value of a reversed range')
-    assert_in_delta(lerp(start_int, last_int, x[1]), 160, delta = 0.00001, msg = 'lerps to an intermediate value')
-    assert_in_delta(lerp(start_int, last_int, x[2]), 200, delta = 0.00001, msg = 'lerps to the last value of a range')
+    start0 = 300
+    last0 = 200
+    start_int = 0
+    last_int = 200
+    assert_in_delta(lerp(start0, last0, x[0]), 250, 0.00001, 'produces a intermediate value of a reversed range')
+    assert_in_delta(lerp(start_int, last_int, x[1]), 160, 0.00001, 'lerps to an intermediate value')
+    assert_in_delta(lerp(start_int, last_int, x[2]), 200, 0.00001, 'lerps to the last value of a range')
   end
 
   def test_constrain
     x_int = [15, 2_500, -2_500]
-    start_int, last_int = 0, 200
-    assert_in_delta(constrain(x_int[0], start_int, last_int), 15, delta = 0.00001)
-    assert_in_delta(constrain(x_int[1], start_int, last_int), 200, delta = 0.00001)
-    assert_in_delta(constrain(x_int[2], start_int, last_int), 0, delta = 0.00001)
+    start_int = 0
+    last_int = 200
+    assert_in_delta(constrain(x_int[0], start_int, last_int), 15, 0.00001)
+    assert_in_delta(constrain(x_int[1], start_int, last_int), 200, 0.00001)
+    assert_in_delta(constrain(x_int[2], start_int, last_int), 0, 0.00001)
     xf = [15.0, 2_500.0, -2_500.0]
-    startf, lastf = 0, 200.0
-    assert_in_delta(constrain(xf[0], startf, lastf), 15.0, delta = 0.00001, msg = 'constrain to 0..200')
-    assert_in_delta(constrain(xf[1], startf, lastf), 200.0, delta = 0.00001, msg = 'constrain to 0..200')
-    assert_in_delta(constrain(xf[2], startf, lastf), 0.0, delta = 0.00001, msg = 'constrain to 0..200')
+    startf = 0
+    lastf = 200.0
+    assert_in_delta(constrain(xf[0], startf, lastf), 15.0, 0.00001, 'constrain to 0..200')
+    assert_in_delta(constrain(xf[1], startf, lastf), 200.0, 0.00001, 'constrain to 0..200')
+    assert_in_delta(constrain(xf[2], startf, lastf), 0.0, 0.00001, 'constrain to 0..200')
   end
 end

data/test/respond_to_test.rb

@@ -2,7 +2,7 @@
 
 require_relative 'test_helper'
 
-METHODS = %i(
+METHODS = %i[
   alpha
   ambient
   ambient_light
@@ -181,7 +181,7 @@ METHODS = %i(
   update_pixels
   vertex
   width
-)
+].freeze
 
 class TestSketch < Processing::App
   def settings
@@ -193,7 +193,9 @@ class TestSketch < Processing::App
   end
 
   def draw
-    exit if frame_count > 30
+    exit if frame_count > 20
+
+    background 0, 200, 0
   end
 end
 

data/test/sketches/key_event.rb

@@ -1,9 +1,9 @@
 #!/usr/bin/env jruby
-require 'picrate'
+# frozen_string_literal: true
 
+require 'picrate'
 
 class CustomProxySketch < Processing::App
-
   # A simple demonstration of vanilla processing 'reflection' methods using
   # picrate :library_proxy. See my_library.rb code for the guts.
   load_libraries :library_proxy, :my_library

data/test/sketches/library/my_library/my_library.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # This class demonstrates how by inheriting from the abstract class LibraryProxy
 # we can access 'keyEvent' and 'draw'  (Note we need a draw method even
 # though can be empty)
@@ -20,6 +22,7 @@ class MyLibrary < LibraryProxy
   def keyEvent(e) # NB: need camel case for reflection to work
     return unless e.get_action == KeyEvent::PRESS
     return if e.get_key > 122 # else we can't use :chr
+
     case e.get_key.chr.upcase
     when 'S'
       app.send :hide, false

data/test/test_helper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 gem 'minitest'
 require 'java'
 require_relative '../lib/picrate'

data/test/vecmath_spec_test.rb

@@ -1,12 +1,12 @@
+# frozen_string_literal: true
+
 require_relative 'test_helper'
 
 Java::Monkstone::PicrateLibrary.load(JRuby.runtime)
 
-
 Dir.chdir(File.dirname(__FILE__))
 
 class VecmathTest < Minitest::Test
-
   # duck for Vec2D constructor
   Point = Struct.new(:x, :y)
   # duck for Vec3D constructor
@@ -15,12 +15,11 @@ class VecmathTest < Minitest::Test
   Pointless = Struct.new(:a, :b)
   # non-duck to test fail
   Pointless3 = Struct.new(:a, :b, :c)
-  def setup
-
-  end
+  def setup; end
 
   def test_equals
-    x, y = 1.0000001, 1.01
+    x = 1.0000001
+    y = 1.01
     a = Vec2D.new(x, y)
     assert_equal(a.to_a, [x, y], 'Failed to return Vec2D as an Array')
   end
@@ -32,7 +31,8 @@ class VecmathTest < Minitest::Test
   end
 
   def test_copy_equals
-    x, y = 1.0000001, 1.01
+    x = 1.0000001
+    y = 1.01
     a = Vec2D.new(x, y)
     b = a.copy
     assert_equal(a.to_a, b.to_a, 'Failed deep copy')
@@ -58,7 +58,8 @@ class VecmathTest < Minitest::Test
   end
 
   def test_copy_not_equals
-    x, y = 1.0000001, 1.01
+    x = 1.0000001
+    y = 1.01
     a = Vec2D.new(x, y)
     b = a.copy
     b *= 0
@@ -119,7 +120,7 @@ class VecmathTest < Minitest::Test
 
   def test_random
     a = Vec2D.random
-    assert a.kind_of? Vec2D
+    assert a.is_a? Vec2D
     assert_in_epsilon(a.mag, 1.0)
   end
 
@@ -131,7 +132,7 @@ class VecmathTest < Minitest::Test
 
   def test_mag
     a = Vec2D.new(-3, -4)
-    assert_in_epsilon(a.mag, 5, 0.001,'Failed to return magnitude of vector')
+    assert_in_epsilon(a.mag, 5, 0.001, 'Failed to return magnitude of vector')
   end
 
   def test_mag_variant
@@ -225,14 +226,16 @@ class VecmathTest < Minitest::Test
   end
 
   def test_rotate
-    x, y = 20, 10
+    x = 20
+    y = 10
     b = Vec2D.new(x, y)
     a = b.rotate(Math::PI / 2)
     assert_equal(a, Vec2D.new(-10, 20), 'Failed to rotate vector by scalar radians')
   end
 
   def test_hash_index
-    x, y = 10, 20
+    x = 10
+    y = 20
     b = Vec2D.new(x, y)
     assert_equal(b[:x], x, 'Failed to hash index')
   end
@@ -267,7 +270,7 @@ class VecmathTest < Minitest::Test
     a = Vec2D.new(200, 0)
     b = Vec2D.new(0, 200)
     # Expected result is an area, twice that of the triangle created by the vectors
-    assert_equal((a).cross(b).abs, 40_000.0, 'Failed area test using 2D vector cross product')
+    assert_equal(a.cross(b).abs, 40_000.0, 'Failed area test using 2D vector cross product')
   end
 
   def test_cross_non_zero # Could be used to calculate area of triangle
@@ -286,7 +289,9 @@ class VecmathTest < Minitest::Test
   end
 
   def test_equals3
-    x, y, z = 1.0000001, 1.01, 0.0
+    x = 1.0000001
+    y = 1.01
+    z = 0.0
     a = Vec3D.new(x, y)
     assert_equal(a.to_a, [x, y, z], 'Failed to return Vec3D as an Array')
   end
@@ -317,14 +322,18 @@ class VecmathTest < Minitest::Test
   end
 
   def test_copy_equals3
-    x, y, z = 1.0000001, 1.01, 1
+    x = 1.0000001
+    y = 1.01
+    z = 1
     a = Vec3D.new(x, y, z)
     b = a.copy
     assert_equal(a.to_a, b.to_a, 'Failed deep copy')
   end
 
   def test_copy_not_equals3
-    x, y, z = 1.0000001, 1.01, 6.0
+    x = 1.0000001
+    y = 1.01
+    z = 6.0
     a = Vec3D.new(x, y, z)
     b = a.copy
     b *= 0
@@ -369,13 +378,13 @@ class VecmathTest < Minitest::Test
 
   def test_random3
     a = Vec3D.random
-    assert a.kind_of? Vec3D
+    assert a.is_a? Vec3D
     assert_in_epsilon(a.mag, 1.0)
   end
 
   def test_assign_value3
     a = Vec3D.new(3, 5)
-    a.x=23
+    a.x = 23
     assert_equal(a.x, 23, 'Failed to assign x value')
   end
 
@@ -504,7 +513,9 @@ class VecmathTest < Minitest::Test
   end
 
   def test_hash_key3
-    x, y, z = 10, 20, 50
+    x = 10
+    y = 20
+    z = 50
     b = Vec3D.new(x, y, z)
     assert_equal(b[:x], x, 'Failed hash key access')
     assert_equal(b[:y], y, 'Failed hash key access')

data/vendors/Rakefile

@@ -2,12 +2,13 @@
 
 require 'fileutils'
 require 'rake/clean'
+require_relative './geany'
 WARNING = 'WARNING: wget download failed you could do a manual download'
 SOUND = 'sound.zip'
-SOUND_VERSION = 'v1.3.2'
-VIDEO = 'video-2.0-beta4.zip'
-VIDEO_VERSION = 'r6-v2.0-beta4'
-EXAMPLES = '0.5.3'
+PROCESSING_GITHUB = 'https://github.com/processing'
+VIDEO = 'video.zip'
+DOWNLOAD = 'releases/download/latest'
+EXAMPLES = '0.5.5'
 HOME_DIR = ENV['HOME']
 LIBRARY = File.join(HOME_DIR, '.picrate', 'libraries')
 PROJECT_DIR = File.join(HOME_DIR, 'projects')
@@ -46,16 +47,24 @@ task download_samples: ["#{EXAMPLES}.tar.gz"]
 
 desc 'download sound library'
 task :download_sound do
-  wget_base = 'wget -P https://github.com/processing/processing-sound'
-  wget_string = [wget_base, 'releases/download/latest', SOUND].join('/')
-  system wget_string
+  wget_base = ['wget', PROCESSING_GITHUB].join(' ')
+  wget_string = [wget_base, 'processing-sound', DOWNLOAD, SOUND].join('/')
+  begin
+    sh wget_string
+  rescue StandardError
+    warn(WARNING)
+  end
 end
 
 desc 'download video library'
 task :download_video do
-  wget_base = 'wget -P /tmp https://github.com/processing/processing-video'
-  wget_string = [wget_base, 'releases/download', VIDEO_VERSION, VIDEO].join('/')
-  system wget_string
+  wget_base = ['wget', PROCESSING_GITHUB].join(' ')
+  wget_string = [wget_base, 'processing-video', DOWNLOAD, VIDEO].join('/')
+  begin
+    sh wget_string
+  rescue StandardError
+    warn(WARNING)
+  end
 end
 
 desc 'initialize ~/.picrate directories'
@@ -69,9 +78,11 @@ task :install_config do
     FileUtils.mkdir_p "#{HOME_DIR}/.config/geany/templates/files"
     FileUtils.cp 'picrate.rb', "#{HOME_DIR}/.config/geany/templates/files"
   end
-  unless File.exist? "#{HOME_DIR}/projects/sketchbook/picrate_sketches.geany"
-    FileUtils.mkdir_p "#{HOME_DIR}/projects/sketchbook"
-    FileUtils.cp 'picrate_sketches.geany', "#{HOME_DIR}/projects/sketchbook"
+  project_dir = File.join(HOME_DIR, 'projects')
+  unless File.exist? File.join(project_dir, 'picrate_sketches.geany')
+    FileUtils.mkdir_p "#{HOME_DIR}/projects"
+    config = GeanyConfig.new(project_dir)
+    config.save(File.join(project_dir, 'picrate_sketches.geany'))
   end
 end
 
@@ -86,15 +97,16 @@ end
 
 desc 'copy sound library'
 task copy_sound: SOUND do
-  system "unzip -d /tmp /tmp/#{SOUND}"
-  FileUtils.rm_r "#{LIBRARY}/sound" if File.exist? "#{LIBRARY}/sound"
-  FileUtils.cp_r '/tmp/sound', LIBRARY
+  sh "unzip #{SOUND}"
+  sh "rm -r #{LIBRARY}/sound" if File.exist? "#{LIBRARY}/sound"
+  sh "cp -r sound #{LIBRARY}"
+  sh 'rm -r sound'
 end
 
 desc 'copy video library'
-task copy_video: "/tmp/#{VIDEO}" do
-  system "unzip -d /tmp /tmp/#{VIDEO}"
-  FileUtils.rm_r "#{LIBRARY}/video" if File.exist? "#{LIBRARY}/video"
-  FileUtils.mkdir_p "#{LIBRARY}/video/library"
-  FileUtils.mv Dir.glob("/tmp/video/library/*.jar"), "#{LIBRARY}/video/library"
+task copy_video: VIDEO do
+  sh "unzip #{VIDEO}"
+  sh "rm -r #{LIBRARY}/video" if File.exist? "#{LIBRARY}/video"
+  sh "cp -r video #{LIBRARY}"
+  sh 'rm -r video'
 end