cf3 0.0.5 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 3a43e223b34bc4d0176687c3fe5ca7cb300922a7
-  data.tar.gz: 6000229d2e1fbd9430b9c0e089af616483f6cd4f
+SHA256:
+  metadata.gz: b71a0ec8b28c1fd599073b44c0d22ae1522d505b7969a535edf3dfed706491ad
+  data.tar.gz: 36e50b4f45a4e77c6937e2e268f654c8563647045c44824c798cfb18879f3494
 SHA512:
-  metadata.gz: 5f51b3aca67a217c2703e1d3d5032732c91da2c2ee0480f38a3eca8e9da78b15911404b3996ba15a57609ae2dd408026ab253289cf9a939c53bc673b26c72c9b
-  data.tar.gz: 738c38f20fbf60890f34353e47d7d7155d2de3f5199e712ebc4cbc08fe61ae728c400c055824fbc71230d7f7a4257a91cfdaa3171f7e2683700ad43e61970357
+  metadata.gz: d7d53015eeaff4ffe3b5a641c29e1774ce02ed669f2b4447b2da66d6babbc03c58c48b9c69292bc10ba71895069bc03a22f078aaff1337a434f8a5384234d581
+  data.tar.gz: 4aca28d84f49c8f11bda4f028c20c8b9334eed0cab8259f3011129ff1f3c8e72d4dd4dcb67f7afc310e9525e1b36041d96dacb1a8b25d418d7fb81eda282c1ad

data/CHANGELOG

@@ -1,3 +1,9 @@
+v1.0.0 About time for a regular release number, fixed and update some examples NB: see also https://github.com/funatsufumiya/cf3ruby_sketches
+
+v0.0.7 Update for processing3 and JRubyArt by Funatsufumiya san (aka funniti)
+
+v0.0.6 Some tidy up remove @finished
+
 v0.0.4 Introduce :w and :h as options to supplement size
   * start support for width and height options (:w, :h)
 

data/Gemfile

@@ -1,5 +1,5 @@
 source 'https://rubygems.org'
 
 # Specify your gem's dependencies in cf3ruby.gemspec
-ruby "1.9.3", :engine => "jruby", :engine_version => "1.7.5"
+ruby "2.3.3", :engine => "jruby", :engine_version => "9.1.15.0"
 gemspec

data/README.md

@@ -1,38 +1,42 @@
 # cf3ruby
 
-**context-free DSL for ruby-1.9 and CF3 syntax** 
+Now updated to be compatible with ruby 2.4, JRubyArt 1.4.4 (newer version of ruby-processing), and Processing 3+.*
+
+**context-free DSL for ruby-2.4 and CF3 syntax**
+
+Very much derived from [context-free.rb](https://github.com/jashkenas/context_free) by Jeremy Ashkenas this version is updated to be more in line with CF3 and ruby 2.3 syntax. NB this version will not work with original ruby-processing.
 
-Very much derived from [context-free.rb][] by Jeremy Ashkenas this version is updated to be more in line with CF3 and ruby 1.9 syntax. Tested as working with last rubygems release of ruby-processing (v 1.0.11) as well as the current [version][] (v 2.4.0).
-[context-free.rb]:https://github.com/jashkenas/context_free/
-[version]:https://github.com/monkstone/ruby-processing/releases/
 ## Installation
 
-To use this library you need install jruby (preferably jruby-1.7.9+), you will also need [ruby-processing][] to be installed (minimum version 1.0.11, preferred version 2.4.0). There are three ways you can install this library:-
+To use this library you need install jruby (preferably jruby-9.1+), you will also need [ruby-processing/JRubyArt](https://github.com/ruby-processing/JRubyArt) to be installed (preferred version 1.4.4). There are three ways you can install this library:-
 
 ***rake test and gem install***
 
-Either clone this repository, or download a [snapshot][].
+Clone this repository,
 
 ```bash
-cd cf3ruby 
+cd cf3ruby
 jruby -S rake test # builds and tests gem (mouse click on frame for test image to show)
-jruby -S gem install cf3-0.0.3.gem # may need sudo access
+jruby -S gem install cf3-1.0.0.gem # may need sudo access
 ```
 
 ***local bundle install***
 
-Either clone this repository, or download a [snapshot].
+Clone this repository,
 
 ```bash
-cd cf3
-bundle install          # using regular installed bundler may need to set GEM_PATH
+cd cf3ruby
+# bundle install          # using regular installed bundler may need to set GEM_PATH
 jruby -S bundle install # if you installed bundler with jruby
 ```
 
 ***gem install from rubygems***
+
 ```bash
-gem install cf3            # regular install may need to set GEM_PATH env variable
-jruby -S gem install cf3   # jruby install 
+# When rubygems is updatd for this release.
+
+# gem install cf3            # regular install may need to set GEM_PATH env variable
+# jruby -S gem install cf3   # jruby install
 ```
 it couldn't be easier could it?
 
@@ -44,19 +48,15 @@ cf3samples           # should work
 jruby -S cf3samples  # else if installed with jruby this should also work
 ```
 
-As for running ruby-processing, ( _it requires the external jruby flag prior to ruby-processing-2.1.2_ )
+As for running ruby-processing,
 ```bash
-rp5 run city.rb # providing you installed both ruby-processing and cf3ruby using jruby
+k9 --run city.rb # providing you installed both ruby-processing (JRubyArt) and cf3ruby using jruby
 
 ```
-You should read the [ruby-processing_documentation][] on using rubygems.
+You should read the [JRubyArt documentation](https://github.com/ruby-processing/JRubyArt/blob/master/README.md) on using rubygems.
 
 ## Contributing
 
-[Contributing][]
-[contributing]:CONTRIBUTING.md
-[ruby-processing_documentation]:https://github.com/jashkenas/ruby-processing/wiki/Using-Rubygems/
-[snapshot]:https://github.com/monkstone/cf3ruby/releases
+See [CONTRIBUTING.md](CONTRIBUTING.md)
 
 ![Y](http://3.bp.blogspot.com/-KNBKD7lArMA/UNBayboXQFI/AAAAAAAAD7A/YAgZCewTOxQ/s400/y.png)
-

data/Rakefile

@@ -1,4 +1,4 @@
-require "bundler/gem_tasks"
+#require "bundler/gem_tasks"
 
 task :install => :build do
   sh "jruby -S gem install #{Dir.glob('*.gem').join(' ')} --no-ri --no-rdoc"
@@ -9,7 +9,11 @@ task :build do
 end
 
 task :test do
-  sh "jruby -S rp5 run test/test_cf3.rb"
+  sh "jruby -S k9 --run test/test_cf3.rb"
 end
 
+task :clean do
+  sh "rm *.gem"
+end 
+
 task :default => [:install]

data/cf3ruby.gemspec

@@ -4,26 +4,26 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'cf3/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "cf3"
+  spec.name          = 'cf3'
   spec.version       = Cf3::VERSION
-  spec.authors       = ["Jeremy Ashkenas", "Martin Prout"]
-  spec.email         = ["martin_p@lineone.net"]
+  spec.authors       = ['Jeremy Ashkenas', 'Martin Prout, Funatsufumiya']
+  spec.email         = ['mamba2928@yahoo.co.uk']
   spec.description   = <<-EOF
-    A library for ruby-processing, that allows the writing of context free 
+    A library for JRubyArt, that allows the writing of context free
     sketches (like context free art) in a ruby DSL. It is a bit of a toy
-    compared to the c++ version.  However you can get quite a bit of 
+    compared to the c++ version.  However you can get quite a bit of
     satisfaction creating an interesting graphic, and you can't always
     predict what you are going to get.
   EOF
   spec.summary       = %q{A ruby-DSL library for CF3 sketches}
-  spec.homepage      = "http://learning-ruby-processing.blogspot.co.uk/"
-  spec.default_executable   = "cf3samples" 
-  spec.license       = "GPL3"
+  spec.homepage      = 'http://learning-ruby-processing.blogspot.co.uk/'
+  spec.default_executable   = 'cf3samples'
+  spec.licenses = %w(GPL-3.0 LGPL-2.0)
   spec.files         = `git ls-files`.split($/)
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.executables   = ["cf3samples"] 
-  spec.require_paths = ["lib"]
-  spec.add_runtime_dependency 'ruby-processing', '>= 1.0.11'
-  spec.add_development_dependency "bundler", "~> 1.3"
-  spec.add_development_dependency "rake"
+  spec.executables   = ['cf3samples']
+  spec.require_paths = ['lib']
+  spec.add_runtime_dependency 'jruby_art', '~> 1.4'
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake', '~> 12.0'
 end

data/lib/cf3.rb

@@ -1,42 +1,37 @@
-# A Context-Free library for Ruby-Processing, inspired by
-# based on context_free.rb by Jeremy Ashkenas. Which in turn
-# was inspired by contextfreeart.org
-
 module Processing
-
+  # A Context-Free library for JRubyArt, inspired by and
+  # based on context_free.rb by Jeremy Ashkenas. That in turn
+  # was inspired by contextfreeart.org
   class ContextFree
-
     include Processing::Proxy
-
     attr_accessor :rule, :app, :width, :height
 
-    AVAILABLE_OPTIONS = [:x, :y, :w, :h, :rotation, :size, :flip, :color, :hue, :saturation, :brightness, :alpha]
-    HSB_ORDER         = {hue: 0, saturation: 1, brightness: 2, alpha: 3}
-    TRIANGLE_TOP      = -1 / Math.sqrt(3)
-    TRIANGLE_BOTTOM   = Math.sqrt(3) / 6
+    AVAILABLE_OPTIONS = %i[
+      x y w h rotation size flip color hue saturation brightness alpha
+    ].freeze
+    HSB_ORDER       = { hue: 0, saturation: 1, brightness: 2, alpha: 3 }.freeze
+    TRIANGLE_TOP    = -1 / Math.sqrt(3)
+    TRIANGLE_BOTTOM = Math.sqrt(3) / 6
     RADIANS = (Math::PI / 180.0)
     # Define a context-free system. Use this method to create a ContextFree
     # object. Call render() on it to make it draw.
     def self.define(&block)
       cf = ContextFree.new
-      cf.instance_eval &block
+      cf.instance_eval(&block)
       cf
     end
 
-
     # Initialize a bare ContextFree object with empty recursion stacks.
     def initialize
-      @app          = $app
-      @graphics     = $app.g
-      @width        = $app.width
-      @height       = $app.height
-      @finished     = false
+      @app = Processing.app
+      @graphics     = @app.g
+      @width        = @app.width
+      @height       = @app.height
       @rules        = {}
       @rewind_stack = []
       @matrix_stack = []
     end
 
-
     # Create an accessor for the current value of every option. We use a values
     # object so that all the state can be saved and restored as a unit.
     AVAILABLE_OPTIONS.each do |option_name|
@@ -45,17 +40,16 @@ module Processing
       end
     end
 
-
     # Here's the first serious method: A Rule has an
     # identifying name, a probability, and is associated with
     # a block of code. These code blocks are saved, and indexed
     # by name in a hash, to be run later, when needed.
     # The method then dynamically defines a method of the same
     # name here, in order to determine which rule to run.
-    def shape(rule_name, prob=1, &proc)
-      @rules[rule_name] ||= {procs: [], total: 0}
+    def shape(rule_name, prob = 1, &proc)
+      @rules[rule_name] ||= { procs: [], total: 0 }
       total = @rules[rule_name][:total]
-      @rules[rule_name][:procs] << [(total...(prob+total)), proc]
+      @rules[rule_name][:procs] << [(total...(prob + total)), proc]
       @rules[rule_name][:total] += prob
       unless ContextFree.method_defined? rule_name
         self.class.class_eval do
@@ -63,9 +57,8 @@ module Processing
             def #{rule_name}(options)
               merge_options(@values, options)
               pick = determine_rule(#{rule_name.inspect})
-              @finished = true if @values[:size] < @values[:stop_size]
-              unless @finished
-                get_ready_to_draw
+              unless (@values[:size] - @values[:stop_size]) < 0
+                prepare_to_draw
                 pick[1].call(options)
               end
             end
@@ -74,37 +67,37 @@ module Processing
       end
     end
 
-
     # Rule choice is random, based on the assigned probabilities.
     def determine_rule(rule_name)
       rule = @rules[rule_name]
-      chance = rand * rule[:total]
-      pick = @rules[rule_name][:procs].select {|the_proc| the_proc[0].include?(chance) }
-      return pick.flatten
+      chance = rand(0.0..rule[:total])
+      @rules[rule_name][:procs].select do |the_proc|
+        the_proc[0].include?(chance)
+      end.flatten
     end
 
-
     # At each step of the way, any of the options may change, slightly.
     # Many of them have different strategies for being merged.
     def merge_options(old_ops, new_ops)
       return unless new_ops
       # Do size first
-      old_ops[:size] *= new_ops[:size] if new_ops[:size]
+      old_ops[:size] *= new_ops.fetch(:size, 1.0)
       new_ops.each do |key, value|
         case key
-        when :size
+        # when :size
         when :x, :y
-          old_ops[key] = value * old_ops[:size]
+          old_ops[key] = value * old_ops.fetch(:size, 1.0)
         when :rotation
           old_ops[key] = value * RADIANS
         when :hue, :saturation, :brightness, :alpha
           adjusted = old_ops[:color].dup
-          adjusted[HSB_ORDER[key]] *= value
+          adjusted[HSB_ORDER[key]] *= value unless key == :hue
+          adjusted[HSB_ORDER[key]] += value if key == :hue
           old_ops[:color] = adjusted
         when :flip
           old_ops[key] = !old_ops[key]
         when :w, :h
-          old_ops[key] = value * old_ops[:size]
+          old_ops[key] = value * old_ops.fetch(:size, 1.0)
         when :color
           old_ops[key] = value
         else # Used a key that we don't know about or trying to set
@@ -113,133 +106,125 @@ module Processing
       end
     end
 
-
     # Using an unknown key let's you set arbitrary values,
     # to keep track of for your own ends.
     def merge_unknown_key(key, value, old_ops)
       key_s = key.to_s
-      if key_s.match(/^set/)
-        key_sym = key_s.sub('set_', '').to_sym
-        if key_s.match(/(brightness|hue|saturation)/)
-          adjusted = old_ops[:color].dup
-          adjusted[HSB_ORDER[key_sym]] = value
-          old_ops[:color] = adjusted
-        else
-          old_ops[key_sym] = value
-        end
+      return unless key_s =~ /^set/
+      key_sym = key_s.sub('set_', '').to_sym
+      if key_s =~ /(brightness|hue|saturation)/
+        adjusted = old_ops[:color].dup
+        adjusted[HSB_ORDER[key_sym]] = value
+        old_ops[:color] = adjusted
+      else
+        old_ops[key_sym] = value
       end
     end
 
-
     # Doing a 'split' saves the context, and proceeds from there,
     # allowing you to rewind to where you split from at any moment.
-    def split(options=nil, &block)
+    def split(options = nil)
       save_context
       merge_options(@values, options) if options
       yield
       restore_context
     end
 
-
     # Saving the context means the values plus the coordinate matrix.
     def save_context
       @rewind_stack.push @values.dup
       @matrix_stack << @graphics.get_matrix
     end
 
-
     # Restore the values and the coordinate matrix as the recursion unwinds.
     def restore_context
       @values = @rewind_stack.pop
       @graphics.set_matrix @matrix_stack.pop
     end
 
-
     # Rewinding goes back one step.
     def rewind
-      @finished = false
       restore_context
       save_context
     end
 
-
     # Render the is method that kicks it all off, initializing the options
     # and calling the first rule.
-    def render(rule_name, starting_values={})
-      @values = {x: 0, y: 0,
-                 rotation: 0, flip: false,
-                 size: 20, w: nil, h: nil,
-                 start_x: width/2, start_y: height/2,
-                 color: [180, 0.5, 0.5, 1],
-                 stop_size: 1.5}
+    def render(rule_name, starting_values = {})
+      @values = defaults
       @values.merge!(starting_values)
-      @finished = false
       @app.reset_matrix
       @app.rect_mode CENTER
       @app.ellipse_mode CENTER
       @app.no_stroke
-      @app.color_mode HSB, 360, 1.0, 1.0, 1.0    # match cfdg
-      @app.translate @values[:start_x], @values[:start_y]
-      self.send(rule_name, {})
+      @app.color_mode HSB, 360, 1.0, 1.0, 1.0 # match cfdg
+      @app.translate @values.fetch(:start_x, 0), @values.fetch(:start_y, 0)
+      send(rule_name, {})
     end
 
+    def defaults
+      {
+        x: 0,
+        y: 0,
+        rotation: 0,
+        flip: false,
+        size: 20,
+        start_x: width / 2,
+        start_y: height / 2,
+        color: [180, 0.5, 0.5, 1],
+        stop_size: 1.5
+      }
+    end
 
     # Before actually drawing the next step, we need to move to the appropriate
     # location.
-    def get_ready_to_draw
-      @app.translate(@values[:x], @values[:y])
+    def prepare_to_draw
+      @app.translate(@values.fetch(:x, 0), @values.fetch(:y, 0))
       sign = (@values[:flip] ? -1 : 1)
       @app.rotate(sign * @values[:rotation])
     end
 
-
     # Compute the rendering parameters for drawing a shape.
     def get_shape_values(some_options)
       old_ops = @values.dup
-      merge_options(old_ops, some_options) if some_options
-      @app.fill *old_ops[:color]
-      return old_ops[:size], old_ops
+      merge_options(old_ops, some_options) unless some_options.empty?
+      @app.fill(*old_ops[:color])
+      old_ops
     end
 
-
-    # Square, circle, and ellipse are the primitive drawing
-    # methods, but hopefully triangles will be added soon.
-    def square(some_options={})
-      size, options = *get_shape_values(some_options)
+    # Square, circle, ellipse and triangles are the primitive shapes
+    def square(some_options = {})
+      options = get_shape_values(some_options)
       width = options[:w] || options[:size]
       height = options[:h] || options[:size]
-      rot = options[:rotation] 
+      rot = options[:rotation]
       @app.rotate(rot) if rot
       @app.rect(0, 0, width, height)
-      @app.rotate(-rot) if rot  
+      @app.rotate(-rot) if rot
     end
 
-
-    def circle(some_options={})
-      size, options = *get_shape_values(some_options)
+    def circle(some_options = {})
+      get_shape_values(some_options)
       @app.ellipse(0, 0, size, size)
     end
 
-    def triangle(some_options={})
-      size, options = *get_shape_values(some_options)
-      rot = options[:rotation] 
+    def triangle(some_options = {})
+      options = get_shape_values(some_options)
+      rot = options[:rotation]
       @app.rotate(rot) if rot
       @app.triangle(0, TRIANGLE_TOP * size, 0.5 * size, TRIANGLE_BOTTOM * size, -0.5 * size, TRIANGLE_BOTTOM * size)
       @app.rotate(-rot) if rot
     end
 
-
-    def ellipse(some_options={})
-      size, options = *get_shape_values(some_options)
+    def ellipse(some_options = {})
+      options = get_shape_values(some_options)
       width = options[:w] || options[:size]
       height = options[:h] || options[:size]
-      rot = some_options[:rotation] 
+      rot = some_options[:rotation]
       @app.rotate(rot) if rot
       @app.oval(options[:x] || 0, options[:y] || 0, width, height)
       @app.rotate(-rot) if rot
     end
-    alias_method :oval, :ellipse
-
+    alias oval ellipse
   end
-
 end