picrate 0.0.2-java → 0.0.3-java

data/docs/_methods/sketch_title.md

@@ -0,0 +1,24 @@
+---
+layout: post
+title:  "sketch_title"
+permalink: methods/sketch_title.html
+---
+The `sketch_title` method is probably unique to propane and JRubyArt, it is a convenient way to set the title of the sketch frame. Normally you only want to set the title once, so sensible it belongs in the setup definition.
+
+```ruby
+def setup
+  sketch_title 'My sketch'
+end
+```
+
+Should you want a dynamic readout of say `frame_rate`, put it in the draw loop (however there will most likely be some sort of performance penalty) eg:-
+
+```ruby
+
+TITLE_FORMAT = 'frame: %d - fps %0.2f'.freeze
+  # ... some code
+def draw
+  sketch_title(format(TITLE_FORMAT, frame_count, frame_rate)) if frame_count % 10 == 0
+  # ... some code
+end
+```

data/docs/_modules/custom.md

@@ -0,0 +1,61 @@
+---
+layout: post
+title:  "Custom"
+keywords: using, module
+permalink: modules/custom.html
+---
+Ruby users will be familiar with the use of modules, but may not be aware that they can be of particular use in propane (and jruby generally)
+
+### Namespace to wrap java packages ###
+
+Use `include_package` within a Ruby Module to import a Java Package's classes on const_missing
+
+Use `include_package 'package_name'` in a Ruby Module to support namespaced access to the Java classes in the package. This is similar to Java's `package xxx.yyy.zzz;` format. It is also legal to use `java_import 'package_name'`, that is similar to `import package_name.*`.
+
+__Example__: using include_package in a module
+```ruby
+module MyApp
+ include_package 'org.apache.logging.log4j'
+ # now any class from "org.apache.logging.log4j" will be available within
+ # this module, ex if "org.apache.logging.log4j.LogManager" exists ...
+ Logger = LogManager.getLogger('MyApp')
+end
+```
+
+__Example__: create a Ruby Module called JavaLangDemo that includes the classes in the Java package java.lang.
+```ruby
+module JavaLangDemo
+  include_package 'java.lang'
+  # alternately, use the #import method
+  # java_import 'java.lang'
+end
+```
+
+Now you can prefix the desired Java Class name with `JavaLangDemo::` to access the included class
+
+__Example__: Simpler form available in a propane sketch
+
+But we have made this even easier for you because since we wrap the processing sketch in a `Processing` module so you are able to just use `include_package` in your propane sketches. See below
+example where include several `ddf.minim` packages in a sketch:-
+
+```ruby
+load_library :minim
+include_package 'ddf.minim'
+include_package 'ddf.minim.ugens'
+# the effects package is needed because the filters are there for now.
+include_package 'ddf.minim.effects'
+```
+
+However you may still want to use full method above to create a namespace (which you may need to prefix with `Processing::` if accessed outside the `Processing` module)
+
+__Example__: multiple (nested) packages in a module
+```ruby
+module Hype
+  include_package 'hype.extended.colorist'
+  include_package 'hype.extended.layout'
+  # a sometimes better alternative, is to use the java_import for specific classes
+  # java_import 'hype.extended.colorist.HColorPool'
+  # java_import 'hype.extended.layout.HGridLayout'
+end
+```
+Now you can prefix the desired Java Class name with `Hype::` to access the included classes `Hype::HColorPool` and `Hype::HGridLayout`.

data/docs/_modules/helper_methods.md

@@ -0,0 +1,10 @@
+---
+layout: post
+title:  "Propane::HelperMethods"
+keywords: Propane, module
+permalink: modules/helper_methods.html
+---
+The [HelperMethods][HelperMethods] module provides additional methods to the propane sketch.
+
+
+[HelperMethods]:https://github.com/ruby-processing/propane/blob/master/lib/propane/helper_methods.rb

data/docs/_modules/interface.md

@@ -0,0 +1,66 @@
+---
+layout: post
+title:  "Implementing java interfaces"
+keywords: using, module
+permalink: modules/interface.html
+---
+Java interfaces are mapped to modules in JRuby. This means that you can also reopen the corresponding module and add further methods on the JRuby side. JRuby classes can now implement more than one Java interface. Since Java interfaces are mapped to modules in JRuby, you implement them not by subclassing, but by mixing them in.
+
+```ruby
+class SomeJRubyObject
+  include java.lang.Runnable
+  include java.lang.Comparable
+end
+```
+
+Another example is implementing an interface from  the `jbox2d` library, here is the java interface (_sans comments_):-
+
+```java
+package org.jbox2d.callbacks;
+
+import org.jbox2d.collision.Manifold;
+import org.jbox2d.dynamics.contacts.Contact;
+
+public interface ContactListener {
+	public void beginContact(Contact contact);
+	public void endContact(Contact contact);
+	public void preSolve(Contact contact, Manifold oldManifold);
+	public void postSolve(Contact contact, ContactImpulse impulse);
+}
+```
+
+And this is how we implement that interface in propane see [full example here][collision_listening], note empty methods are just fine.
+
+```ruby
+# A custom listener allows us to get the physics engine to
+# to call our code, on say contact (collisions)
+class CustomListener
+  include ContactListener
+
+  def begin_contact(cp)
+    # Get both fixtures
+    f1 = cp.getFixtureA
+    f2 = cp.getFixtureB
+    # Get both bodies
+    b1 = f1.getBody
+    b2 = f2.getBody
+    # Get our objects that reference these bodies
+    o1 = b1.getUserData
+    o2 = b2.getUserData
+    return unless [o1, o2].all? { |obj| obj.respond_to?(:change) }
+    o1.change
+    o2.change
+  end
+
+  def end_contact(_cp)
+  end
+
+  def pre_solve(_cp, _m)
+  end
+
+  def post_solve(_cp, _ci)
+  end
+end
+```
+
+[collision_listening]:https://github.com/ruby-processing/picrate-examples/blob/master/external_library/gem/pbox2d/collision_listening.rb

data/docs/_modules/processing.md

@@ -0,0 +1,7 @@
+---
+layout: post
+title:  "Processing"
+keywords: PiCrate, module, Processing
+permalink: modules/processing.html
+---
+The Processing module wraps all PiCrate sketches, and allows us to provide functionality like `library_loader`, but also to unobtrusively import vanilla processing jars. Other benefits are it provides a namespace, and allows us to alias vanilla processing variables and methods. The HelperMethods module is also included.

data/docs/_modules/processing_proxy.md

@@ -0,0 +1,28 @@
+---
+layout: post
+title:  "Processing::Proxy"
+keywords: processing, module, namespace
+permalink: modules/processing_proxy.html
+---
+The sole purpose of the `Processing::Proxy` module is to provide access to the `Processing::App` variables and methods similar to the access to [Inner classes][inner] afforded by vanilla processing. To do this your class should `include Processing::Proxy` as below:-
+
+```ruby
+class MyClass
+  include Processing::Proxy
+  # access to sketch methods and variables is similar to java Inner class
+end
+```
+
+Now we know this is not `kosher` and as you get more comfortable with propane you may eschew this egregious hack, but initially at least you will find it highly convenient. There are plenty of examples included with the samples (because it so damn convenient). See [frame_of_reference][sketch] sketch and [Plane][Plane] and [Cylinder][Cylinder] classes
+
+
+[sketch]:https://github.com/ruby-processing/picrate-examples/blob/master/library/vecmath/vec3d/frame_of_reference.rb
+[Plane]:https://github.com/ruby-processing/picrate-examples/blob/master/library/vecmath/vec3d/library/geometry/lib/plane.rb
+[Cylinder]:https://github.com/ruby-processing/picrate-examples/blob/master/library/vecmath/vec3d/library/geometry/lib/cylinder.rb
+
+The hair shirted brigade might want to take a look at `forwardable` and make their classes `extend Forwardable` instead. There are some examples include with the samples see the [revolute_joint][joint] pbox2d example with the [Windmill][Windmill] and [ParticleSystem][ParticleSystem] classes for example.
+
+[joint]:https://github.com/ruby-processing/picrate-examples/blob/master/examples/forwardable_module_examples/pbox2d/revolute_joint/revolute_joint.rb
+[Windmill]:https://github.com/ruby-processing/picrate-examples/blob/master/examples/forwardable_module_examples/pbox2d/revolute_joint/library/revolute_joint/lib/windmill.rb
+[ParticleSystem]:https://github.com/ruby-processing/picrate-examples/blob/master/examples/forwardable_module_examples/pbox2d/revolute_joint/library/revolute_joint/lib/particle_system.rb
+[inner]: {{ site.github.url }}/magic/java

data/docs/_objects/class/class.md

@@ -0,0 +1,7 @@
+---
+layout: post
+title:  "Class Variable"
+keywords: App, PApplet, @@
+permalink: objects/class.html
+---
+A class variable in ruby has a name beginning with `@@`. It is seldom necessary to use a class variable in PiCrate.

data/docs/_objects/global/global.md

@@ -0,0 +1,7 @@
+---
+layout: post
+title:  "Global Variable"
+keywords: App, PApplet, $
+permalink: objects/global.html
+---
+A global variable in ruby a name beginning with `$`. It can be referred to from anywhere in a program. Before initialization, a global variable has the special value nil. Global variables should be used sparingly. They are dangerous because they can be written to from anywhere. Overuse of globals can make isolating bugs difficult; it also tends to indicate that the design of a program has not been carefully thought out. Whenever you do find it necessary to use a global variable, be sure to give it a descriptive name that is unlikely to be inadvertently used for something else later (calling it something like $foo as above is probably a bad idea).

data/docs/_objects/instance/instance.md

@@ -0,0 +1,74 @@
+---
+layout: post
+title:  "Instance Variable"
+keywords: attr_reader, @, instance
+permalink: objects/instance.html
+---
+A instance variable in ruby has a name beginning with `@`.  It often makes sense for it to be initialised at `setup` (not necessarily in the loop could be called method).
+
+```ruby
+#!/usr/bin/env jruby -v -W2
+require 'picrate'
+
+class Tree < Processing::App
+  # http://processing.org/learning/topics/tree.html
+  # by Joe Holt
+
+  def setup
+    size 200, 200
+  end
+
+  def setup
+    sketch_title 'Tree'
+    color_mode RGB, 1
+    frame_rate 30
+    smooth
+    @x = 0.0
+    @dx = width / 100
+    @start_time = Time.now
+    @frame_time = nil
+  end
+
+  def draw
+    t = Time.now
+    if @frame_time
+      fps = 1.0 / (t - @frame_time)
+      # printf "%0.1f fps\n", fps
+    end
+    @frame_time = t
+
+# ...etc
+
+Tree.new
+```
+
+For a variable that gets called quite a lot in a propane sketch it makes sense to create a getter using `attr_reader`. This has the fortunate side effect of making it blindingly obvious when you are assigning it to a new value/instance (it also makes the sketch variable readable by external classes).
+
+```ruby
+#!/usr/bin/env jruby -w
+require 'picrate'
+class Interpolate < Processing::App
+  attr_reader :x, :y
+
+  def setup
+    sketch_title 'Interpolate'
+    @x, @y = 0, 0
+    no_stroke
+  end
+
+  def draw
+    background(51)
+    @x = lerp(x, mouse_x, 0.05)
+    @y = lerp(y, mouse_y, 0.05)
+    fill(255)
+    stroke(255)
+    ellipse(x, y, 66, 66)
+  end
+
+  def settings
+    size(640, 360)
+  end
+end
+
+Interpolate.new
+```

data/docs/_objects/numeric/numeric.md

@@ -0,0 +1,37 @@
+---
+layout: post
+title:  "Numeric Objects"
+keywords: numeric, float, fixnum, rational
+permalink: objects/numeric.html
+---
+
+In a sense this section is only required because of `OO` languages that support the concept of a `primitive` type (Java, C++) in languages like ruby and smalltalk and even python everything is an object. So you should prefer ruby `x.abs` to vanilla processings `abs(x)` etc.
+
+### Fixnum ###
+
+Holds Integer values that can be represented in a native machine word (minus 1 bit). If any operation on a [Fixnum][fixnum] exceeds this range, the value is automatically converted to a Bignum.
+
+### Float ###
+
+[Float objects][float] represent inexact real numbers using the native architecture's double-precision floating point representation.  Floating point has a different arithmetic and is an inexact number.
+
+#### constants ###
+* __DIG__ The minimum number of significant decimal digits in a double-precision floating point. Usually defaults to 15.
+* __EPSILON__ The difference between 1 and the smallest double-precision floating point number.  Usually defaults to 2.2204460492503151e-16.
+
+### Bignum ###
+
+[Bignum objects][bignum] hold integers outside the range of Fixnum. Bignum objects are created automatically when integer calculations would otherwise overflow a Fixnum. When a calculation involving Bignum objects returns a result that will fit in a Fixnum, the result is automatically converted.
+
+### Rational ###
+
+A rational number can be represented as a paired integer number; `a/b` (b>0). Where `a` is numerator and `b` is denominator. Integer `a` equals rational `a/1` mathematically.  A [rational object][rational] is an exact number, which helps you to write program without any rounding errors.
+
+### PiCrate ###
+
+We have re-opened the `Numeric` class to implement `radians` and `degree` methods, which means that instead of using `radians(x)` a processing method, you should use `x.radians` in propane. But this should not be so necessary now we have `DegLut.cos` and `DegLut.sin` methods.
+
+[float]:https://ruby-doc.org/core-2.2.0/Float.html
+[fixnum]:https://ruby-doc.org/core-2.2.0/Fixnum.html
+[bignum]:https://ruby-doc.org/core-2.2.0/Bignum.html
+[rational]:https://ruby-doc.org/core-2.2.0/Rational.html

data/docs/_posts/2018-05-06-getting_started.md

@@ -6,3 +6,63 @@ categories: PiCrate update
 ---
 You need to install jdk8, there's probably easy ways to do it, if you have more that one version of java installed you could use `update-alternatives` tool to control them.
 Then install JRuby.
+
+```bash
+jgem install picrate # also installs arcball dependency
+```
+
+Install samples
+
+```bash
+picrate -i Samples
+```
+
+Install processing libraries
+
+```bash
+picrate -i Sound
+picrate -i glvideo # preferred over vanilla video for now
+```
+
+Create template
+
+```bash
+picrate -c my_sketch 600 400
+```
+creates file my_sketch.rb
+
+```ruby
+#!/usr/bin/env jruby
+# frozen_string_literal: false
+require 'picrate'
+
+class MySketch < Processing::App
+  def settings
+    size 200, 200
+  end
+
+  def setup
+    sketch_title 'My Sketch'
+  end
+
+  def draw
+
+  end
+end
+MySketch.new
+
+```
+
+Edit in say vim
+```bash
+vim my_sketch.rb
+:!jruby % # from vim runs the sketch
+```
+
+Alternatively to run sketches
+
+```bash
+jruby my_sketch.rb
+```
+
+Or even `chmod +x my_sketch.rb` to make an executable script.

data/docs/_posts/2018-05-06-processing-api.md

@@ -0,0 +1,68 @@
+---
+layout: post
+title:  "Processing API"
+date:   2018-05-24 07:34:13
+categories: PiCrate update
+permalink: /methods/alternative_methods/
+---
+<style>
+table{
+    border-collapse: collapse;
+    border-spacing: 0;
+    border:2px solid #0000FF;
+}
+
+th{
+    border:2px solid #0000FF;
+}
+</style>
+You can use most [processing methods][processing] in picrate, but where possible you should prefer these ruby alternatives (you should also prefer Vec2D and Vec3D to PVector).
+Here is a list of ruby alternatives to some 'processing' convenience methods; which with the exception of `color`, `map1d`, `p5map`, `degrees` and `radians` are just regular ruby methods.
+
+|function       |processing            |picrate           |
+|----------     |-------------       |------               |
+|camera         |`camera(args)`      |`kamera(hash_args)`  |
+|color string   |`color(#cc6600)`      |`color('#cc6600')` |
+|date/time      |                      |`t = Time.now`       |
+|               |`day`                   |`t.day`              |
+|               |`hour`                  |`t.hour`             |
+|               |`minute`                |`t.minute`           |
+|               |`second`                |`t.second`           |
+|               |`year`                  |`t.year`             |
+|custom math    |`map(x, b0, eo, b1, e1)`|`map1d(x, (b0..e0), (b1..e1))`|
+|               |`map(x, b0, eo, b1, e1)`|`p5map(x, b0, e0, b1, e1)`|
+|               |`max(array)            `|`array.max`        |
+|               |`min(array)            `|`array.min`        |
+|conversion     |`degrees(theta)`        |`theta.degrees`    |
+|conversion     |`radians(theta)`        |`theta.radians`    |
+|conversion     |`hex(string)`           |`string.hex`       |
+|conversion     |`unhex(string)`         |`string.to_i(base=16)`|
+|conversion     |`binary(c)`             |`c.to_s(2)`        |
+|conversion     |`unbinary(string)`      |`string.to_i(base=2)`|
+|math           |`abs(x)`                |`x.abs`            |
+|math           |`round(x)`              |`x.round`          |
+|math           |`ceil(x)`               |`x.ceil`           |
+|math           |`random(x)`             |`rand(x)`          |
+|math           |`random(a, b)`          |`rand(a..b)`       |
+|math power     |`pow(a, b)`             |`a**b`             |
+|square         |`sq(x)`                 |`x * x`            |
+|print          |`println(x)`            |`puts x`           |
+|format         |`trim(string)`          |`string.strip`     |
+|format         |`nf(float_value, 0, 2)` |`format('%.2f', float_value)`|
+|format         |`nf(num, digit)`        |`num.to_s.rjust(digit, '0')`|
+|format         |`nf(nf(num, left, right)`|`see below`     |
+
+`num.to_s.rjust(left, '0').ljust(left + right, '0')`
+
+For examples of using time in sketches see [learning JRubyArt blog][time], [timestamp][timestamp] and this [clock sketch][clock].
+
+For example of `kamera` usage see [kamera][kamera]. To use `selectInput` see link to `File Chooser` in page header. We actually use the ruby Enumerable methods `max` and `min` methods to make `max(*array)` and `min(*methods)` available in picrate, so you could use the processing form providing you splat the array, but it is simpler to use the ruby method directly further you have the option with ruby of changing the [comparator via a block][comparator].
+
+NB: if you have any trouble with `save` or `save_frame` then use the option of providing an absolute path.  You can easily do this using the `data_path` wrapper that does it for you see [data_path method][data_path].
+
+[data_path]:{{site.github.url}}/data_path/
+[time]:https://monkstone.github.io/time
+[timestamp]:https://monkstone.github.io/timestamp/
+[clock]:https://github.com/ruby-processing/picrate-examples/blob/master//library/fastmath/clock.rb
+[kamera]:https://github.com/ruby-processing/picrate-examples/blob/master//basics/camera/kmove_eye.rb
+[processing]:https://processing.org/reference/

data/docs/_posts/2018-05-11-arch-linux-arm.md

@@ -0,0 +1,17 @@
+---
+layout: post
+title:  "Installing JRuby on Archlinux arm"
+date:   2018-05-24 07:34:13
+categories: PiCrate update
+---
+It is quite likely that people wishing to experiment with PiCrate on arm have moved beyond the raspbian distribution. As a first step [archlinuxarm][alarm] which seems to be well thought out. Installing jdk8 and jruby should be as simple as:-
+
+```bash
+sudo pacman -Syu # get up to data
+sudo pacman jdk-arm # but I'm not 100% sure what version is installed jdk8 is reqd / and preferred over later
+sudo archlinux-java set java-8-openjdk/jre # case you have more than one java installed
+sudo pacman jruby # should install latest version
+```
+
+
+[alarm]:https://archlinuxarm.org/platforms/armv6/raspberry-pi

data/docs/about.md

@@ -4,7 +4,13 @@ title: About
 permalink: /about/
 ---
 
-PiCrate is an experimental ruby wrapper for processing for the raspberrypi (raspbian image), like the vanilla processing version this uses the 32 bit video drivers. I could be 64 bit drivers work, but is possible they don't play too well together (to use the 64 bit drivers uncomment them in Rakefile and gemspec and comment out the 32 bit drivers). 
+PiCrate is an experimental ruby wrapper for processing for the raspberrypi (raspbian image), like the vanilla processing version this uses the 32 bit video drivers. It could be that 64 bit drivers work, but is possible they don't play too well together (to use the 64 bit drivers uncomment them in Rakefile and gemspec and comment out the 32 bit drivers). Also `native_folder.rb` will need amending for sound etc libraries.
+See [github repo][repo]
+
+See also [gottfreid haider][gottfreid] at vanilla processing and vanilla [processing wiki][wiki]
 
 [jruby_art]: https://ruby-processing.github.io/index.html
 [propane]:https://ruby-processing.github.io/propane/
+[repo]:https://github.com/ruby-processing/PiCrate
+[gottfreid]:https://github.com/processing/processing/wiki/Raspberry-Pi#download
+[wiki]:https://github.com/processing/processing/wiki/Raspberry-Pi

data/docs/classes.md

@@ -0,0 +1,10 @@
+---
+layout: page
+title: Classes
+---
+
+{% for class in site.classes %}
+  <h2>{{ item.title }}</h2>
+  <p>{{ item.description }}</p>
+  <p><h2><a href="{{ class.url | prepend: site.github.url }}">{{ class.title }}</a></h2></p>
+{% endfor %}

data/docs/editors.md

@@ -0,0 +1,10 @@
+---
+layout: page
+title: Editors
+---
+
+{% for editor in site.editors %}
+  <h2>{{ item.title }}</h2>
+  <p>{{ item.description }}</p>
+  <p><h2><a href="{{ editor.url | prepend: site.github.url }}">{{ editor.title }}</a></h2></p>
+{% endfor %}

data/docs/gems.md

@@ -0,0 +1,11 @@
+---
+layout: page
+title: Gems
+---
+{% for gem in site.gems %}
+  <h2>{{ item.title }}</h2>
+  <p>{{ item.description }}</p>
+  <p><h2><a href="{{ gem.url | prepend: site.github.url }}">{{ gem.title }}</a></h2></p>
+{% endfor %}
+
+<p>If you are new to ruby, see <a href="http://guides.rubygems.org/what-is-a-gem/">what is a gem here</a></p>

data/docs/libraries.md

@@ -0,0 +1,20 @@
+---
+layout: page
+title: Libraries
+---
+It is possible to use vanilla <a href="https://www.processing.org/reference/libraries/">processing libraries</a> with picrate, but we also provide pure ruby libraries eg `boids`.  Most libraries can be loaded using the <a href="https://ruby-processing.github.io/PiCrate/load_library">load_library</a> method, the exception being those that can be loaded as <a href="https://ruby-processing.github.io/PiCrate/gems.html">gems</a>. It is also possible use the <a href="https://ruby-processing.github.io/PiCrate/load_library">load_library</a> method to load local libraries for your sketches see <a href="https://github.com/ruby-processing/picrate-examples/blob/master/demo/raining.rb">raining.rb</a>, if you stick with PiCrate library conventions. For more advanced sketches it is often a good idea to create your own <a href="https://en.wikipedia.org/wiki/Library_%28computing%29">libraries</a>.
+
+{% for library in site.libraries %}
+  <h2>{{ item.title }}</h2>
+  <p>{{ item.description }}</p>
+  <p><h2><a href="{{ library.url | prepend: site.github.url }}">{{ library.title }}</a></h2></p>
+{% endfor %}
+
+<h4>Key To Library Types</h4>
+<ol>
+<li>Builtin pure ruby eg boids</li>
+<li>Builtin wrapping java eg video_event</li>
+<li>Custom pure ruby</li>
+<li>Custom java (see also pbox2d gem)</li>
+<li>Regular processing libraries (see also gems for toxiclibs etc)</li>
+</ol>

data/docs/magic.md

@@ -0,0 +1,11 @@
+---
+layout: page
+title: Magic
+---
+Spoiler alert, initially a least it is better just to accept the magic works...
+
+{% for spell in site.magic %}
+  <h2>{{ item.title }}</h2>
+  <p>{{ item.description }}</p>
+  <p><h2><a href="{{ spell.url | prepend: site.github.url }}">{{ spell.title }}</a></h2></p>
+{% endfor %}

data/docs/methods.md

@@ -0,0 +1,10 @@
+---
+layout: page
+title: Methods
+---
+
+{% for method in site.methods %}
+  <h2>{{ item.title }}</h2>
+  <p>{{ item.description }}</p>
+  <p><h2><a href="{{ method.url | prepend: site.github.url }}">{{ method.title }}</a></h2></p>
+{% endfor %}

data/docs/modules.md

@@ -0,0 +1,12 @@
+---
+layout: page
+title: Modules
+---
+
+{% for module in site.modules %}
+  <h2>{{ item.title }}</h2>
+  <p>{{ item.description }}</p>
+  <p><h2><a href="{{ module.url | prepend: site.github.url }}">{{ module.title }}</a></h2></p>
+{% endfor %}
+
+<p>If you are new to ruby, you can read more about <a href="https://www.tutorialspoint.com/ruby/ruby_modules.htm">modules here</a></p>

data/docs/objects.md

@@ -0,0 +1,9 @@
+---
+layout: page
+title: Variables and Objects
+---
+{% for object in site.objects %}
+  <h2>{{ item.title }}</h2>
+  <p>{{ item.description }}</p>
+  <p><h2><a href="{{ object.url | prepend: site.github.url }}">{{ object.title }}</a></h2></p>
+{% endfor %}

data/lib/picrate/version.rb

@@ -1,4 +1,4 @@
 # frozen_string_literal: true
 module PiCrate
-  VERSION = '0.0.2'.freeze
+  VERSION = '0.0.3'.freeze
 end

data/picrate.gemspec

@@ -15,7 +15,7 @@ Gem::Specification.new do |gem|
   gem.summary       = %q{ruby wrapper for processing-3.3.7 on raspberrypi and linux64}
   gem.homepage      = 'https://ruby-processing.github.io/PiCrate/'
   gem.files         = `git ls-files`.split($/)
-  gem.files << 'lib/picrate-0.0.2.jar'
+  gem.files << 'lib/picrate-0.0.3.jar'
   gem.files << 'lib/gluegen-rt-2.3.2.jar'
   gem.files << 'lib/jogl-all-2.3.2.jar'
   gem.files << 'lib/gluegen-rt-2.3.2-natives-linux-amd64.jar'
@@ -31,5 +31,5 @@ Gem::Specification.new do |gem|
   gem.add_runtime_dependency 'arcball', '~> 1.0', '>= 1.0.0'
   gem.require_paths = ['lib']
   gem.platform      = 'java'
-  gem.requirements << 'java runtime >= 1.8.0_151+'
+  gem.requirements << 'java runtime >= 1.8.0_161+'
 end

data/pom.rb

@@ -1,7 +1,7 @@
 project 'picrate', 'http://maven.apache.org' do
 
   model_version '4.0.0'
-  id 'ruby-processing:picrate:0.0.2'
+  id 'ruby-processing:picrate:0.0.3'
   packaging 'jar'
 
   description 'An integrated processing-core (somewhat hacked), with additional java code for a jruby version of processing.'