rubocop fixes

Author: monkstone

processing_app/topics/lsystems/Rakefile

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Simple demo Rakefile to autorun samples in current directory
 # adjust path to k9 executable, and or opts as required
 
@@ -8,7 +10,7 @@ task default: [:demo]
 
 desc 'demo'
 task :demo do
-  samples_list.shuffle.each{ |sample| run_sample sample }
+  samples_list.shuffle.each { |sample| run_sample sample }
 end
 
 def samples_list

processing_app/topics/lsystems/chequer.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ########################################################
 # Chequer implemented using a grammar library
 # Lindenmayer System in JRubyArt by Martin Prout
@@ -30,7 +32,7 @@ class Chequer
   def initialize(xpos, ypos)
     @xpos = xpos
     @ypos = ypos
-    @axiom = 'F-F-F-F'        # Axiom
+    @axiom = 'F-F-F-F' # Axiom
     @grammar = Grammar.new(axiom, 'F' => 'FF-F-F-F-FF')
     @draw_length = 500
     stroke 0, 255, 0
@@ -67,6 +69,3 @@ def create_grammar(gen)
     @production = @grammar.generate gen
   end
 end
-
-
-

processing_app/topics/lsystems/csplant.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ########################################################
 # csplant.rb
 # A 3D Plant implemented using a Context Sensitive
@@ -54,7 +56,7 @@ def render
     specular(255, 255, 255)
     shininess(1.0)
     repeat = 1
-    production.each_char do |ch|
+    production.scan(/./) do |ch|
       case ch
       when 'F'
         translate(0, len / -2, 0)
@@ -98,4 +100,3 @@ def create_grammar(gen)
 def settings
   size 800, 800, P3D
 end
-

processing_app/topics/lsystems/cstest.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ###########################
 # cstest.rb (use rp5 run ..
 # test of cs_grammar library
@@ -17,15 +19,13 @@ def draw
   (0..7).each do |i|
     grammar = Grammar.new(
       'baaaaaa',
-      'b<a' => 'b',   # context sensitive rule replace a when preceded by b
+      'b<a' => 'b', # context sensitive rule replace a when preceded by b
       'b' => 'a'
     )
     text grammar.generate(i), 30, i * 25
   end
 end
 
-
 def settings
   size 125, 250, P2D
 end
-

processing_app/topics/lsystems/david_tour.rb

@@ -1,16 +1,18 @@
+# frozen_string_literal: true
+
 load_library :grammar
 
 ########################################################
 # A David Tour fractal implemented using a
 # Lindenmayer System in JRubyArt by Martin Prout
 ########################################################
-class DavidTour  
+class DavidTour
   attr_reader :draw_length, :xpos, :ypos, :theta, :axiom, :grammar
   DELTA = Math::PI / 3 # 60 degrees
 
   def initialize(xpos, ypos)
     @axiom = 'FX-XFX-XFX-XFX-XFX-XF'   # Axiom
-    @theta  = 0
+    @theta = 0
     @grammar = Grammar.new(
       axiom,
       'F' => '!F!-F-!F!',              # Rules
@@ -29,7 +31,7 @@ def create_grammar(gen)
   def translate_rules(prod)
     swap = false
     [].tap do |points| # An array to store lines as a flat array of points
-      prod.each do |ch|
+      prod.scan(/./) do |ch|
         case ch
         when 'F'
           points << xpos << ypos << (@xpos += draw_length * Math.cos(theta)) << (@ypos -= draw_length * Math.sin(theta))
@@ -69,4 +71,3 @@ def draw
 def settings
   size(800, 900, P2D)
 end
-

processing_app/topics/lsystems/doily.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ########################################################
 # A Doily fractal implemented using a
 # Lindenmayer System in JRubyArt by Martin Prout
@@ -27,7 +29,7 @@ def translate_rules(prod)
     coss = ->(orig, alpha, len) { orig + len * DegLut.cos(alpha) }
     sinn = ->(orig, alpha, len) { orig - len * DegLut.sin(alpha) }
     [].tap do |pts| # An array to store line vertices as Vec2D
-      prod.each do |ch|
+      prod.scan(/./) do |ch|
         case ch
         when 'F'
           pts << vec.copy
@@ -76,7 +78,7 @@ def render(points)
 end
 
 def renderer
-  @renderer ||= GfxRender.new(self.g)
+  @renderer ||= GfxRender.new(g)
 end
 
 def settings

processing_app/topics/lsystems/koch_fractal.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 load_library :koch
 
 def setup
   sketch_title 'Koch'
   background(255)
-  frame_rate(1)  # Animate slowly
+  frame_rate(1) # Animate slowly
   @k = KochFractal.new(width, height)
 end
 
@@ -21,4 +23,3 @@ def settings
   size(800, 250)
   smooth 8
 end
-

processing_app/topics/lsystems/library/cs_grammar/cs_grammar.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 ##################################
 # The grammar class stores rules
 # in two Hashes, one for cs rules,
@@ -39,7 +41,7 @@ def generate(repeat = 0) # repeat iteration grammar rules
     prod
   end
 
-  def new_production(prod)  # single iteration grammar rules
+  def new_production(prod) # single iteration grammar rules
     @idx = -1
     prod.gsub!(/./) do |ch|
       get_rule(prod, ch)

processing_app/topics/lsystems/library/grammar/grammar.rb

@@ -10,23 +10,17 @@ def initialize(axiom, rules)
     @rules = rules
   end
 
-  def expand(production, iterations, &block)
-    production.each_char do |token|
-      if rules.key?(token) && iterations.positive?
-        expand(rules[token], iterations - 1, &block)
-      else
-        yield token
-      end
-    end
-  end
-
-  def each(gen)
-    expand(axiom, gen) { |token| yield token }
+  def apply_rules(prod)
+    prod.gsub(/./) { |token| rules.fetch(token, token) }
   end
 
   def generate(gen)
-    [].tap do |output|
-      each(gen) { |token| output << token }
+    return axiom if gen.zero?
+
+    prod = axiom
+    gen.times do
+      prod = apply_rules(prod)
     end
+    prod
   end
 end

processing_app/topics/lsystems/library/koch/koch.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 # Kochline class
 class KochLine
   include Processing::Proxy
@@ -83,7 +85,7 @@ def render
   # for the structure. As we do this over and over again, each line gets broken
   # into 4 lines, which gets broken into 4 lines, and so on. . .
   def iterate(before)
-    [].tap do |now|    # Create empty list
+    [].tap do |now| # Create empty list
       before.each do |l|
         # Calculate 5 koch vectors (done for us by the line object)
         a = l.start