some cleanups

Author: monkstone

samples/processing_app/demos/performance/cubic_grid_retained.rb

@@ -19,9 +19,9 @@ def setup
   no_stroke
   @grid = create_shape(GROUP)
   # Build grid using multiple translations
-  (-(DEPTH/2 + MARGIN) ... (DEPTH/2 - MARGIN)).step(BOX_SIZE) do |i|
-    (-(height + MARGIN) ... (height - MARGIN)).step(BOX_SIZE) do |j|
-      (-(width + MARGIN) ... (width - MARGIN)).step(BOX_SIZE) do |k|
+  (-(DEPTH/2 + MARGIN)...(DEPTH/2 - MARGIN)).step(BOX_SIZE) do |i|
+    (-(height + MARGIN)...(height - MARGIN)).step(BOX_SIZE) do |j|
+      (-(width + MARGIN)...(width - MARGIN)).step(BOX_SIZE) do |k|
         # Base fill color on counter values, abs function
         # ensures values stay within legal range
         @box_fill = color(i.abs.to_i, j.abs.to_i, k.abs.to_i, 50)
@@ -38,21 +38,21 @@ def draw
   background(255)
   hint(DISABLE_DEPTH_TEST)
   # Center and spin grid
-  push_matrix()
-  translate(width/2, height/2, -DEPTH)
+  push_matrix
+  translate(width / 2, height / 2, -DEPTH)
   rotate_y(frame_count * 0.01)
   rotate_x(frame_count * 0.01)
   shape(grid)
-  pop_matrix()
+  pop_matrix
   hint(ENABLE_DEPTH_TEST)
   @fcount += 1
-  m = millis()
+  m = millis 
   if (m - lastm > 1000 * FINT)
     @frate = fcount / FINT
     @fcount = 0
     @lastm = m
-    puts("fps: #{frate}")
+    puts(format('fps: %s', frate))
   end
   fill(0)
-  text("fps: #{frate}", 10, 20)
+  text(format('fps: %s', frate), 10, 20)
 end

samples/processing_app/demos/performance/esfera.rb

@@ -23,7 +23,7 @@ def setup
   @rx = 0
   @ry =0
   no_smooth
-  @radius = height/3.5
+  @radius = height / 3.5
   @orb = HairyOrb.new(self, radius)
   QUANTITY.times do
     orb << create_hair(radius)
@@ -37,9 +37,7 @@ def draw
   no_stroke
   sphere(radius)
   orb.render
-  if (frame_count % 10 == 0)
-    puts(frame_rate)
-  end
+  puts(frame_rate) if (frame_count % 10 == 0)
 end
 
 def create_hair radius
@@ -90,4 +88,4 @@ def render
   end
 end
 
-Hair = Struct.new(:z, :phi, :len, :theta )
+Hair = Struct.new(:z, :phi, :len, :theta )

samples/processing_app/topics/lsystems/chequer.rb

@@ -9,8 +9,8 @@
 
 def setup
   size 600, 600
-  @chequer = Chequer.new width * 0.9, height/10
-  chequer.create_grammar 4  
+  @chequer = Chequer.new width * 0.9, height / 10
+  chequer.create_grammar 4
   no_loop
 end
 
@@ -19,29 +19,30 @@ def draw
   chequer.render
 end
 
+# Chequer class
 class Chequer
   include Processing::Proxy
   attr_accessor :axiom, :grammar, :production, :draw_length, :theta, :xpos, :ypos
   DELTA = HALF_PI
-  
+
   def initialize(xpos, ypos)
-    @xpos = xpos 
-    @ypos = ypos 
+    @xpos = xpos
+    @ypos = ypos
     @axiom = 'F-F-F-F'        # Axiom
     @grammar = Grammar.new(axiom, 'F' => 'FF-F-F-F-FF')
     @draw_length = 500
     stroke 0, 255, 0
-    stroke_weight 2  
+    stroke_weight 2
     @theta = 0
   end
-  
+
   def render
     production.each do |element|
       case element
-      when 'F'                     
+      when 'F'
         x_temp = xpos
         y_temp = ypos
-        @xpos -= draw_length * cos(theta) 
+        @xpos -= draw_length * cos(theta)
         @ypos -= draw_length * sin(theta)
         line(x_temp, y_temp, xpos, ypos)
       when '+'
@@ -53,14 +54,14 @@ def render
       end
     end
   end
-  
+
   ##############################
   # create grammar from axiom and
   # rules (adjust scale)
   ##############################
-  
+
   def create_grammar(gen)
-    @draw_length /=  3**gen
+    @draw_length /= 3**gen
     @production = @grammar.generate gen
   end
 end

samples/processing_app/topics/lsystems/csplant.rb

@@ -1,7 +1,7 @@
 ########################################################
 # csplant.rb
 # A 3D Plant implemented using a Context Sensitive
-# Lindenmayer System in ruby-processing 
+# Lindenmayer System in ruby-processing
 # by Martin Prout (30 January 2013)
 # Hold down 'y' key and drag mouse to rotate about y axis
 ########################################################
@@ -20,29 +20,25 @@ def setup
 def draw
   background 0
   lights
-  translate(0, height*0.3)
+  translate(0, height * 0.3)
   csplant.render
 end
 
 ############
-# CSPlant 
+# CSPlant
 ############
-
 class CSPlant
   include Processing::Proxy
 
   IGNORE = '[]+-^&3'
   attr_reader :grammar, :axiom, :production, :premis, :rule,
-  :theta, :scale_factor, :len, :phi, :len
+              :theta, :scale_factor, :len, :phi, :len
 
   def initialize(len)
     @axiom = 'F'
     @grammar = Grammar.new(
       axiom,
-      {
-        'F' => 'F[-EF[3&A]]E[+F[3^A]]',        
-        'F<E' => 'F[&F[3+A]][^F[3-A]]'
-      },
+      { 'F' => 'F[-EF[3&A]]E[+F[3^A]]', 'F<E' => 'F[&F[3+A]][^F[3-A]]' },
       IGNORE
     )
     @production = axiom

samples/processing_app/topics/lsystems/cstest.rb

@@ -13,13 +13,9 @@ def setup
   (0..7).each do |i|
     grammar = Grammar.new(
       'baaaaaa',
-      {
-        'b<a' => 'b',   # context sensitive rule replace a when preceded by b
-        'b'   =>'a'
-      }
-      )    
+      'b<a' => 'b',   # context sensitive rule replace a when preceded by b
+      'b' => 'a'
+    )
     text grammar.generate(i), 30, i * 25
   end
 end
-
-

samples/processing_app/topics/lsystems/david_tour.rb

@@ -1,13 +1,13 @@
-####################################################
-# The DavidTour fractal has been used to study the
-# Euclidean travelling salesman problem
-####################################################
 load_library :grammar
 
+########################################################
+# A David Tour fractal implemented using a
+# Lindenmayer System in ruby-processing by Martin Prout
+########################################################
 class DavidTour
   import 'grammar'
   attr_reader :draw_length, :xpos, :ypos, :theta, :axiom, :grammar
-  DELTA = Math::PI/3 # 60 degrees
+  DELTA = Math::PI / 3 # 60 degrees
 
   def initialize(xpos, ypos)
     @axiom = 'FX-XFX-XFX-XFX-XFX-XF'   # Axiom
@@ -16,7 +16,7 @@ def initialize(xpos, ypos)
       axiom,
       'F' => '!F!-F-!F!',              # Rules
       'X' => '!X'
-      )
+    )
     @draw_length = 15
     @xpos = xpos
     @ypos = ypos
@@ -29,38 +29,31 @@ def create_grammar(gen)
 
   def translate_rules(prod)
     swap = false
-    points = [] # An empty array to store lines as a flat array of points
-    prod.each do |ch|
-      case(ch)
-      when 'F'
-        points << xpos << ypos << (@xpos += draw_length * Math.cos(theta)) << (@ypos -= draw_length * Math.sin(theta))
-      when '+'
-        @theta += DELTA
-      when '-'
-        @theta += swap ? DELTA : -DELTA
-      when '!'
-        swap = !swap
-      when 'X'
-      else
-        puts("character '#{ch}' not in grammar")
+    [].tap do |points| # An array to store lines as a flat array of points
+      prod.each do |ch|
+        case ch
+        when 'F'
+          points << xpos << ypos << (@xpos += draw_length * Math.cos(theta)) << (@ypos -= draw_length * Math.sin(theta))
+        when '+'
+          @theta += DELTA
+        when '-'
+          @theta += swap ? DELTA : -DELTA
+        when '!'
+          swap = !swap
+        when 'X'
+        else
+          puts("character '#{ch}' not in grammar")
+        end
       end
     end
-    return points
   end
 end
 
-
-
-########################################################
-# A David Tour fractal implemented using a
-# Lindenmayer System in ruby-processing by Martin Prout
-########################################################
-
 attr_reader :points
 
 def setup
   size(800, 900)
-  david = DavidTour.new(width * 0.6, height/4)
+  david = DavidTour.new(width * 0.6, height / 4)
   production = david.create_grammar(5)
   @points = david.translate_rules(production)
   no_loop
@@ -72,4 +65,4 @@ def draw
   points.each_slice(4) do |point|
     line(*point)
   end
-end
+end

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

@@ -1,23 +1,13 @@
-######################################
-# cs_grammar.rb a context sensitive
-# 1-L lsystem grammar for
-# ruby/ruby-processing
-# by Martin Prout (January 2013)
-######################################
-
-
-
 ##################################
 # The grammar class stores rules
 # in two Hashes, one for cs rules,
 # one for context free rules. Rules
 # are filtered on input, and context
 # is checked using get_rule in production
 ##################################
-
 class Grammar
-
   attr_reader :axiom, :context, :no_context, :idx, :ignore
+
   def initialize(axiom, rules, ignore = '')
     @axiom = axiom
     @no_context = {}
@@ -39,44 +29,43 @@ def add_rule(pre, rule)
     elsif pre.length == 1
       @no_context[pre] = rule # key length == 1
     else
-      print 'unrecognized grammar '#{pre}''
+      puts "unrecognized grammar '#{pre}'"
     end
   end
 
   def generate(repeat = 0) # repeat iteration grammar rules
     prod = axiom
     repeat.times { prod = new_production(prod) }
-    return prod
+    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)
     end
   end
 
-  def get_rule prod, ch
+  def get_rule(prod, ch)
     rule = ch # default is return original character as rule (no change)
     @idx += 1 # increment the index of axiom/production as a side effect
     if context.key?(ch)
       if context[ch][1] == '<'
         cs_char = context[ch][0]
-        rule = no_context[context[ch]] if cs_char == get_context(prod, idx, -1) # use context sensitive rule
+        rule = no_context[context[ch]] if cs_char == get_context(prod, idx, -1)
       elsif context[ch][1] == '>'
         cs_char = context[ch][2]
-        rule = no_context[context[ch]] if cs_char == get_context(prod, idx, 1) # use context sensitive rule
+        rule = no_context[context[ch]] if cs_char == get_context(prod, idx, 1)
       end
     else
-      rule = no_context[ch] if no_context.key?(ch) # context free rule if it exists
+      rule = no_context[ch] if no_context.key?(ch)
     end
-    return rule
+    rule
   end
 
   def get_context(prod, idx, inc)
     index = idx + inc
     index += inc while ignore.include?(prod[index])
-    return prod[index]
+    prod[index]
   end
-end
+end

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

@@ -2,7 +2,6 @@
 # Simple lsystem grammar
 ############################
 class Grammar
-
   attr_reader :axiom, :rules
   def initialize(axiom, rules)
     @axiom = axiom
@@ -24,8 +23,8 @@ def each(gen)
   end
 
   def generate(gen)
-    output = []
-    each(gen) { |token| output << token }
-    return output
+    [].tap do |output|
+      each(gen) { |token| output << token }
+    end
   end
-end
+end