oozby 0.3.1 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 65d655bb878ca1d6f884b0ed18f710669e64d6f7
-  data.tar.gz: 4d9e1326e16f2436caa73b9a1a73a43dca9e7a18
+  metadata.gz: 582eb27392751e57f1f1f4b40721f90d1c00b119
+  data.tar.gz: 475814b52c59cfe2914341010f8fd52c8b1329cc
 SHA512:
-  metadata.gz: 87f4f684352daf605291502a0c470c38a181e2263dac1588f177c818486db5a5092e6abd3e6190ac10bbb67e451ac3bb39769e98a88961ea986d868f6c6de151
-  data.tar.gz: 244a08c28e31d3cfd781fd895d34df5c843b2f1f15aa68e1f89ab7173809653b2adf15b1bf407bd4d86255dd622d3b7a97cfb008c93cb7259353a05edca67bfa
+  metadata.gz: 65b282a8ea18ee15d80c339bb389bcd03220b8afbe85c3e30ca3f538d6c730b58dabd69a10a987eb2142c5ff8fa31d0788247c1507eb935a821441c8a1e86464
+  data.tar.gz: 56048c0db5681f7e0e6164f3bea334e967bb61651d506b175622a27402fbb34067ea3ea8c66c387f0d5444d722699caf328ff251a3d34243e2f6568178311c7e

data/bin/oozby

@@ -1,20 +1,13 @@
 #!/usr/bin/env ruby
-require 'thor'
-require 'listen'
-require 'pp'
-require 'rbconfig'
+require 'thor' # command line utility utility
+require 'listen' # listen to filesystem for changes in a smart way
+require 'pp' # pretty printer
+require 'rbconfig' # to get path to ruby binary, for making subprocesses
+require 'colored' # ANSI colouring
 require File.join(__dir__, '..', 'lib', 'oozby')
 
-# motivational exit messages!
-$quit_message = {
-  '0.3.0' => "Have a nice day!",
-  '0.3.1' => "You're a superstar!",
-  '0.3.2' => "Keep up the great work!",
-  '0.3.3' => "Nice job!",
-  '0.3.4' => "It was a pleasure working with you!"
-}
-
 class OozbyUtility < Thor
+  QuitMessage = "All done! ^_^"
   desc "compile some#{File::SEPARATOR}folder", "The Oozby Utility searches a directory and compiles all the .oozby files it finds, creating identically named files with .scad stuck on the end, translated in to OpenSCAD nonsense. Open those files in OpenSCAD app and enable Automatic Reload and Compile in the Design menu, then get to work."
   
   option :verbose, type: :boolean, desc: "Output lots of gunk, to figure out bizarre bugs in Oozby"
@@ -39,10 +32,11 @@ class OozbyUtility < Thor
           handle.write ooz.render
         end
         
-        puts "compiled #{File.basename(path)}"
+        print "[#{Time.now.strftime "%H:%M:%S"}] "
+        puts "Compiled #{File.basename(path).underline}".green
       rescue StandardError, ScriptError, NoMethodError => err
         local_pwd = Dir.pwd
-        puts "#{err.class.name}: #{err.message.sub(local_pwd + File::SEPARATOR, '')}"
+        puts "#{err.class.name.reversed}: #{err.message.sub(local_pwd + File::SEPARATOR, '').red}"
         err.backtrace.each { |line| puts line.sub(local_pwd + File::SEPARATOR, '') }
         puts nil, nil
       end
@@ -60,7 +54,7 @@ class OozbyUtility < Thor
           subprocess_compile File.join(*args)
         end
         
-        puts "Watching folder for changes... (CTRL+C to exit)"
+        puts "Watching folder for changes...".blue + " (" + "CTRL+C".bold + " to exit)"
         Listen.to! directory, filter: /\.oozby$/ do |modified, added, removed|
           modified.each { |path| recompile_handler[path] }
           added.each { |path| recompile_handler[path] }
@@ -68,7 +62,7 @@ class OozbyUtility < Thor
             puts "#{File.basename(path)} deleted."
             if File.exists? "#{path}.scad"
               File.delete("#{path}.scad")
-              puts "Deleted generated .scad file for obsolete #{File.basename(path)}"
+              puts "Deleted #{(File.basename(path) + '.scad').underline}".green
             end
           end
         end
@@ -76,7 +70,7 @@ class OozbyUtility < Thor
     end
   rescue Interrupt => e
     puts ""
-    puts $quit_message[Oozby.version] || $quit_message.values.last
+    puts QuitMessage.blue
   end
   
   private

data/lib/oozby.rb

@@ -1,7 +1,8 @@
 warn "Requires ruby 2.0 or newer" unless RUBY_VERSION.split('.').first.to_i >= 2
 require_relative 'oozby/base'
 require_relative 'oozby/environment'
-require_relative 'oozby/method_preprocessor'
+require_relative 'oozby/preprocessor'
+require_relative 'oozby/preprocessor-definitions'
 require_relative 'oozby/render'
 require_relative 'oozby/element'
 require_relative 'oozby/version'

data/lib/oozby/element.rb

@@ -2,42 +2,43 @@
 class Oozby::Element
   attr_reader :data, :siblings
   
-  def initialize hash, parent_array
+  def initialize hash
     @data = hash
-    @siblings = parent_array
+    @siblings = nil #parent_array
   end
   
   # include the next thing as a child of this thing
   def > other
-    if other.respond_to? :to_oozby_element
-      other = [other]
-    elsif not other.is_a?(Array) or other.any? { |item| not item.respond_to? :to_oozby_element }
-      raise "Can only use > combiner to add Oozby::Element or array of Elements"
-    end
-    
-    # convert all items to real Oozby Elements
-    other = other.map { |item| item.to_oozby_element }
-    
-    # add others as children
-    children.push *(other.map { |item| item.data })
-    
-    # remove children from their previous parents
-    other.each do |thing|
-      thing.siblings = children
-    end
-    
-    other.first
+    raise "Can only combine an Oozby::Element to another Oozby::Element" unless other.respond_to? :to_oozby_element
+    other.to_oozby_element.abduct self.children
+    other
   end
   
-  def index
-    @siblings.index(@data)
+  # add this element to the end of supplied array
+  def abduct into
+    @siblings.delete self if @siblings # remove from current location
+    @siblings = into # our new location is here
+    into.push self # append ourselves to the new parent
   end
   
-  def siblings= new_parent
-    @siblings.delete @data
-    @siblings = new_parent
+  def index
+    @siblings.index(self)
   end
   
+  # def siblings= new_parent
+  #   @siblings.delete self
+  #   @siblings = new_parent
+  # end
+  
+  # replace this element with any number of other elements and hashes
+  # def replace *others
+  #   raise "Can't replace Oozby::Element with things that aren't hash-like" unless others.all? { |x| x.respond_to? :to_h }
+  #   puts "Replacing: #{self} with [#{others.join('; ')}]"
+  #   idx = self.index
+  #   others.each { |x| x.siblings = @siblings if x.respond_to? :siblings= }
+  #   @siblings[idx..idx] = others
+  # end
+  
   [:children, :modifier, :method, :args, :named_args].each do |hash_accessor_name|
     define_method(hash_accessor_name) { @data[hash_accessor_name] }
     define_method("#{hash_accessor_name}=") { |val| @data[hash_accessor_name] = val }
@@ -51,6 +52,16 @@ class Oozby::Element
     end
   end
   
+  def to_s
+    x = args.map { |x| x.inspect }
+    named_args.each { |name, value| x.push "#{name}: #{value.inspect}"}
+    "#{method}(#{x.join(', ')})"
+  end
+  
+  def to_h
+    @data
+  end
+  
   def to_oozby_element
     self
   end

data/lib/oozby/environment.rb

@@ -20,7 +20,7 @@ class Oozby::Environment
     @modifier = nil
     @one_time_modifier = nil
     @preprocess = true
-    @method_preprocessor = Oozby::MethodPreprocessor.new(env: self, ooz: @parent)
+    @method_preprocessor = Oozby::Preprocessor.new(env: self, ooz: @parent)
     @scanned_scad_files = []
   end
   
@@ -80,19 +80,17 @@ class Oozby::Environment
       children = []
     end
     
-    call = {
+    element = Oozby::Element.new({
       method: method_name,
       args: args, named_args: hash,
       children: children, 
       modifier: @one_time_modifier || @modifier,
       call_address: @ast.length
-    }
+    })
     
-    @ast.push(comment: "oozby code: " + JSON.generate(call)) if @parent.debug
-    
-    @ast.push call
-    element = Oozby::Element.new(call, @ast)
-    @method_preprocessor.transform_call(element) if @preprocess
+    @ast.push(comment: "oozby: #{element}") if @parent.debug
+    element = @method_preprocessor.transform_call(element) if @preprocess
+    element.abduct @ast
     @one_time_modifier = nil
     
     return element

data/lib/oozby/preprocessor-definitions.rb

@@ -0,0 +1,403 @@
+class Oozby::Preprocessor
+  ##############################################################################
+  ########## All PUBLIC methods below this line are Preprocessors! #############
+  ##############################################################################
+  public
+  
+  default_filters [:xyz, default: 0]
+  passthrough :rotate
+  passthrough :translate
+  passthrough :mirror
+  default_filters [:xyz, default: 1]
+  passthrough :scale
+  passthrough :resize  
+  
+  default_filters # none for these guys
+  passthrough :multmatrix
+  passthrough :color
+  
+  default_filters :resolution, :layout_defaults, :expanded_names
+  
+  # detect requests for rounded cubes and transfer them over
+  filter :xyz, depth: true, default: 1 # cube has xy coords
+  filter :rename_args, [:r, :cr, :corner_r] => :corner_radius
+  filter :validate, size: [Array, Numeric], center: [true, false], corner_radius: Numeric
+  def cube size: [1,1,1], center: false, corner_radius: 0
+    return rounded_rectangular_prism(size: size, center: center, corner_radius: corner_radius) if corner_radius > 0
+    return call
+  end
+  
+  
+  # detect requests for rounded cylinders and transfer them over
+  filter :rename_args, [:cr, :corner_r] => :corner_radius
+  filter :validate, h: Numeric, r1: [Numeric, nil], r2: [Numeric, nil], r: [Numeric, nil], center: [true, false], corner_radius: Numeric
+  def cylinder h: 1, r1: nil, r2: nil, r: nil, center: false, corner_radius: 0
+    r1, r2 = r, r if r unless r1 || r2
+    return rounded_cylinder(h: h, r1: r1, r2: r2, center: center, corner_radius: corner_radius) if corner_radius > 0
+    return call
+  end
+  
+  passthrough :sphere
+  #passthrough :cylinder
+  passthrough :polyhedron
+  # 2d shapes
+  
+  # detect requests for rounded squares and transfer them over
+  filter :xyz, arg: :size, depth: false, default: 1 # square has xy coords
+  filter :rename_args, [:r, :cr, :corner_r] => :corner_radius
+  filter :validate, size: [Array, Numeric], center: [true, false], corner_radius: Numeric
+  def square size: [1,1], center: false, corner_radius: 0
+    return rounded_rectangle(size: size, center: center, corner_radius: corner_radius) if corner_radius > 0
+    return call
+  end
+  
+  passthrough :circle
+  passthrough :polygon
+  # extrude 2d shapes to 3d shapes
+  filter :expanded_names, height_label: :height
+  passthrough :linear_extrude
+  passthrough :rotate_extrude
+  
+  default_filters # none
+  passthrough :minkowski
+  passthrough :hull
+  passthrough :import
+  passthrough :projection
+  
+  passthrough :union
+  passthrough :difference
+  passthrough :intersection
+  passthrough :render
+  
+  ### Various ngons and prisms:
+  # http://en.wikipedia.org/wiki/Regular_polygon#Regular_convex_polygons
+  polygon_names = {
+    triangle: 3,
+    equilateral_triangle: 3,
+    pentagon: 5,
+    hexagon: 6,
+    heptagon: 7,
+    octagon: 8,
+    nonagon: 9,
+    enneagon: 9,
+    decagon: 10,
+    hendecagon: 11,
+    undecagon: 11,
+    dodecagon: 12,
+    tridecagon: 13,
+    tetradecagon: 14,
+    pentadecagon: 15,
+    hexadecagon: 16,
+    heptadecagon: 17,
+    octadecagon: 18,
+    enneadecagon: 19,
+    icosagon: 20,
+    triacontagon: 30,
+    tetracontagon: 40,
+    pentacontagon: 50,
+    hexacontagon: 60,
+    heptacontagon: 70,
+    octacontagon: 80,
+    enneacontagon: 90,
+    hectogon: 100
+  }
+  polygon_names.each do |shape_name, sides|
+    oozby_alias shape_name, :circle, sides: sides
+  end
+  
+  # make a polygon with an arbitrary number of sides
+  oozby_alias :ngon, :circle, sides: 3
+  # make a prism with an arbitrary number of sides
+  oozby_alias :prism, :cylinder, sides: 3
+  
+  # triangles are an edge case
+  oozby_alias :triangular_prism, :cylinder, sides: 3
+  
+  # for all the rest, transform the prism names automatically
+  polygon_names.each do |poly_name, sides|
+    name = poly_name.to_s
+    if name.end_with? 'gon'
+      name += 'al_prism'
+      oozby_alias name, :cylinder, sides: sides
+    end
+  end
+  
+  
+  
+  ##############################################################################
+  ######################### Begin Filters section! #############################
+  ##############################################################################
+  private
+  # apply resolution settings to element
+  ResolutionNames = { degrees_per_fragment: "$fa", minimum: "$fs", fragments: "$fn" }
+  def resolution
+    res = @env.resolution
+    res.delete_if { |k,v| Oozby::Environment::ResolutionDefaults[k] == v }
+    res.each do |key, value|
+      call.named_args[(ResolutionNames[key] || "$#{key}").to_sym] ||= value
+    end
+  end
+  
+  # filter to patch in layout defaults like center: true when not specified
+  # explicitly in this call
+  def layout_defaults
+    # copy in defaults if not already specified
+    call.named_args.merge!(@env.defaults) { |k,a,b| a }
+  end
+  
+  # filter to rename certain arguments to other things
+  # Usage> filter :rename_args, :old_arg => :new_arg, :other => morer
+  def rename_args pairs
+    pairs.each do |from_keys, to_key|
+      from_keys = [from_keys] unless from_keys.is_a? Array
+      if from_keys.any? { |key| call.named_args[key.to_sym] }
+        value = from_keys.map { |key| call.named_args.delete(key) }.compact.first
+        call.named_args[to_key.to_sym] = value if value != nil
+      end
+    end
+  end
+  
+  # general processing of arguments:
+  #  -o> Friendly names - use radius instead of r if you like
+  #  -o> Ranges - can specify radius: 5...10 instead of r1: 5, r2: 10
+  #  -o> Make h/height consistent (either works everywhere)
+  #  -o> Support inner radius, when number of sides is specified
+  #  -o> Specify diameter and have it halved automatically
+  def expanded_names height_label: :h
+    # let users use 'radius' as longhand for 'r', and some other stuff
+    rename_args(
+      [:radius] => :r,
+      [:radius1, :radius_1] => :r1,
+      [:radius2, :radius_2] => :r2,
+      [:facets, :fragments, :sides] => :"$fn",
+      [:inr, :inradius, :in_radius, :inner_r, :inner_radius] => :ir,
+      [:height, :h] => height_label
+    )
+    
+    # let users specify diameter instead of radius - convert it
+    {  diameter: :r,                    dia: :r,               d: :r,
+      diameter1: :r1, diameter_1: :r1, dia1: :r1, dia_1: :r1, d1: :r1,
+      diameter2: :r2, diameter_2: :r2, dia2: :r2, dia_2: :r2, d2: :r2,
+      id: :ir, inner_diameter: :ir, inner_d: :ir,
+      id1: :ir1, inner_diameter_1: :ir1, inner_diameter1: :ir1,
+      id2: :ir2, inner_diameter_2: :ir2, inner_diameter2: :ir2
+    }.each do |d, r|
+      if call.named_args.key? d
+        data = call.named_args.delete(d)
+        if data.is_a? Range
+          data = Range.new(data.first / 2.0, data.last / 2.0, data.exclude_end?)
+        elsif data.respond_to? :to_f
+          data = data.to_f / 2.0
+        else
+          raise "#{data.inspect} must be Numeric or a Range"
+        end
+        call.named_args[r] = data
+      end
+    end
+    
+    # process 'inner radius' bits
+    { ir: :r, ir1: :r1, ir2: :r2 }.each do |ir, r|
+      if call.named_args.key? ir
+        sides = call.named_args[:"$fn"]
+        raise "Use of inner_radius requires sides/facets/fragments argument to #{call.method}()" unless sides.is_a? Numeric
+        raise "sides/facets/fragments argument must be a whole number (Fixnum)" unless sides.is_a? Fixnum
+        raise "sides/facets/fragments argument must be at least 3 #{call} to use inner_radius" unless sides >= 3
+        inradius = call.named_args.delete(ir)
+        if inradius.is_a? Range
+          circumradius = Range.new(inradius.first.to_f / @env.cos(180.0 / sides),
+                           inradius.first.to_f / @env.cos(180.0 / sides),
+                           inradius.exclude_end?)
+        elsif inradius.respond_to? :to_f
+          circumradius = inradius.to_f / @env.cos(180.0 / sides)
+        else
+          raise "#{inradius.inspect} must be Numeric or a Range"
+        end
+        call.named_args[r] = circumradius
+      end
+    end
+    
+    # convert range radius to r1 and r2 pair
+    if call.named_args[:r].is_a? Range
+      range = call.named_args.delete(:r)
+      call.named_args[:r1] = range.first
+      call.named_args[:r2] = range.last
+    end
+  end
+  
+  # filter calls to a method, transforming x, y, and optionally z arguments in
+  # to a 2 or 3 item array, setting it to the argument named 'arg' or setting
+  # it as the first numerically indexed argument if that is unspecified. A
+  # default value can be supplied.
+  # Usage> filter :xyz, default: 1, arg: :size, depth: false
+  def xyz default: 0, arg: false, depth: true
+    if [:x, :y, :z].any? { |name| call.named_args.include? name }
+      # validate args
+      [:x, :y, :z].each do |key|
+        if call.named_args.has_key? key
+          unless call.named_args[key].is_a? Numeric
+            raise "#{key} must be Numeric, value #{call.named_args[key].inspect} is not."
+          end
+        end
+      end
+      
+      coords = [call.named_args.delete(:x), call.named_args.delete(:y)]
+      coords.push call.named_args.delete(:z) if depth
+      coords.map! { |x| x or default } # apply default value to missing data
+      
+      # if argument name is specified, use that, otherwise make it the first argument in the call
+      if arg
+        call.named_args[arg] = coords
+      else
+        call.args.unshift coords
+      end
+    end
+  end
+  
+  
+  # simple validator to check particular named arguments conform to required types
+  # or exactly match a set of values
+  # Usage> filter :validate, argument_name: Symbol, other_argument: ["yes", "no"], radius: [Numeric, Range]
+  def validate args = {}
+    args.keys.each do |args_keys|
+      acceptable = if args[args_keys].respond_to? :each then args[args_keys] else [args[args_keys]] end
+      key_list = if args_keys.respond_to? :each then args_keys else [args_keys] end
+      key_list.each do |key|
+        # for this key, check it matches acceptable list, if specified
+        if call.named_args.keys.include? key
+          value = call.named_args[key]
+          if acceptable.none? { |accepts| accepts === value }
+            raise "#{call.method}'s argument #{key} must be #{acceptable.inspect}"
+          end
+        end
+      end
+    end
+  end
+  
+  # require certain arguments be specified to a processed method
+  # Usage> filter :require_args, :first_arg, :second_arg
+  def require_args *list
+    list.each do |name|
+      raise "#{call.method} requires argument #{name}" unless call.named_args.keys.include? name
+    end
+  end
+  
+  
+  def rounded_rectangle size: [1,1], center: false, corner_radius: 0.0, facets: nil
+    size = [size] * 2 if size.is_a? Numeric
+    size = [size[0] || 1, size[1] || 1]
+    raise "Corner radius is too big. Max #{size.min / 2.0} for this square" if corner_radius * 2.0 > size.min
+    corner_diameter = corner_radius * 2.0
+    circle_x = (size[0] / 2.0) - corner_radius
+    circle_y = (size[1] / 2.0) - corner_radius
+    
+    capture do
+      resolution(fragments: (facets || 0)) do
+        translate(if center then [0,0] else [size[0] / 2.0, size[1] / 2.0] end) do
+          union do
+            square([size[0], size[1] - corner_diameter], center = true)
+            square([size[0] - corner_diameter, size[1]], center = true)
+            preprocessor true do
+              resolution(fragments: (_fragments_for(radius: corner_radius).to_f / 4.0).round * 4.0) do
+                translate([ circle_x,  circle_y]) { circle(r: corner_radius) }
+                translate([ circle_x, -circle_y]) { circle(r: corner_radius) }
+                translate([-circle_x, -circle_y]) { circle(r: corner_radius) }
+                translate([-circle_x,  circle_y]) { circle(r: corner_radius) }
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+  
+  # create a rounded cylinder shape
+  def rounded_cylinder h: 1, r1: 1, r2: 1, center: false, corner_radius: 0
+    radii = [r1, r2]
+    raise "corner_radius is too big. Max is #{radii.min} for this cylinder" if corner_radius > radii.min
+    corner_diameter = corner_radius * 2
+    
+    preprocessor = self
+    # use rounded rect to create the body shape
+    capture do
+      facets = preprocessor.call.named_args[:"$fn"] || _fragments_for(radius: radii.min)
+      
+      translate([0,0, if center then -h / 2.0 else 0 end]) >
+      #union do
+      rotate_extrude(:"$fn" => facets) do
+        hull do
+          # table to calculate radii at in between y positions
+          table = { 0.0 => r1, h.to_f => r2 }
+          # offset taking in to account angle of wall, as the line between each
+          # circle after the hull operation will not be from exactly corner_radius
+          # height when the side angle is not 90deg
+          lookup_offset = corner_radius * sin(atan2(r2-r1, h) / 2.0)
+          # bottom right corner
+          translate([lookup(corner_radius + lookup_offset, table) - corner_radius, h - corner_radius]) >
+          circle(r: corner_radius, :"$fn" => facets)
+          # top right corner
+          translate([lookup(h - corner_radius + lookup_offset, table) - corner_radius, corner_radius]) >
+          circle(r: corner_radius, :"$fn" => facets)
+          # center point
+          square([radii.min - corner_radius, h])
+        end
+      end
+    end
+  end
+  
+  # handle rounded cubes
+  def rounded_rectangular_prism size: [1,1,1], center: false, corner_radius: 0, facets: nil
+    size = [size] * 3 if size.is_a? Numeric
+    size = [size[0] || 1, size[1] || 1, size[2] || 1]
+    raise "Radius is too big. Max #{size.min / 2.0} for this cube" if corner_radius * 2.0 > size.min
+    corner_diameter = corner_radius.to_f * 2.0
+
+    preprocessor = self
+    # use rounded rect to create the body shape
+    capture do
+      resolution(fragments: (facets || 0)) do
+        union do
+          offset = if center then [0,0,0] else [size[0].to_f / 2.0, size[1].to_f / 2.0, size[2].to_f / 2.0] end
+          translate(offset) do
+            # extrude the main body parts using rounded_rectangle as the basis
+            linear_extrude(height: size[2] - corner_diameter, center: true) {
+              inject_abstract_tree(preprocessor.send(:rounded_rectangle, size: [size[0], size[1]], center: true, corner_radius: corner_radius)) }
+            rotate([90,0,0]) { linear_extrude(height: size[1] - corner_diameter, center: true) {
+              inject_abstract_tree(preprocessor.send(:rounded_rectangle, size: [size[0], size[2]], center: true, corner_radius: corner_radius)) }}
+            rotate([0,90,0]) { linear_extrude(height: size[0] - corner_diameter, center: true) {
+              inject_abstract_tree(preprocessor.send(:rounded_rectangle, size: [size[2], size[1]], center: true, corner_radius: corner_radius)) }}
+
+            # fill in the corners with spheres
+            xr, yr, zr = size.map { |x| (x / 2.0) - corner_radius }
+            corner_coordinates = [
+              [ xr, yr, zr],
+              [ xr, yr,-zr],
+              [ xr,-yr, zr],
+              [ xr,-yr,-zr],
+              [-xr, yr, zr],
+              [-xr, yr,-zr],
+              [-xr,-yr, zr],
+              [-xr,-yr,-zr]
+            ]
+            preprocessor true do
+              resolution(fragments: (_fragments_for(radius: corner_radius.to_f).to_f / 4.0).round * 4.0) do
+                corner_coordinates.each do |coordinate|
+                  translate(coordinate) do
+                    # generate sphere shape
+                    rotate_extrude do
+                      intersection do
+                        circle(r: corner_radius)
+                        translate([corner_radius, 0, 0]) { square([corner_radius * 2.0, corner_radius * 4.0], center: true) }
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+

data/lib/oozby/preprocessor.rb

@@ -0,0 +1,183 @@
+# The Oozby Method Preprocessor handles requests via the transform_call method
+# and transforms the Oozby::Element passed in, patching in any extra features
+# and trying to alert the user of obvious bugs
+class Oozby::Preprocessor
+  @@method_filters ||= {}
+  @@default_filters ||= []
+  @@queued_filters ||= []
+  # metaprogramming for hooking up filters before method definitions
+  class << self
+    # sets a list of default filters which aren't reset after each method def
+    def default_filters *list
+      @@default_filters = list.map { |x| if x.is_a? Array then x else [x] end }
+      @@queued_filters = @@default_filters.dup
+    end
+    
+    # set a filter to be added only to the next method def
+    def filter filter_name, *options
+      @@queued_filters ||= @@default_filters.dup
+      @@queued_filters.delete_if { |x| x[0] == filter_name } # replace default definitions
+      @@queued_filters.push([filter_name, *options]) # add new filter definition
+    end
+    
+    # detect a method def, store it's filters and reset for next def
+    def method_added method_name
+      finalize_filter method_name
+      super
+    end
+    
+    # def passthrough method_name
+    #   @@method_filters[method_name] = @@queued_filters
+    #   @@queued_filters = @@default_filters.dup
+    # end
+    
+    def finalize_filter method_name
+      @@method_filters[method_name] = @@queued_filters
+      @@queued_filters = @@default_filters.dup
+    end
+    
+    # don't want to define a primary processor method? pass it through manually
+    def passthrough method_name, *arg_names
+      arg_list = arg_names.map { |x| "#{x}: nil" }.join(', ')
+      define_method method_name, &eval("->(#{arg_list}) {nil}")
+    end
+    
+    # get list of filters for a method name
+    def filters_for method_name
+      @@method_filters[method_name] || []
+    end
+    
+    # alias an name to an openscad method optionally with extra defaults
+    # useful for giving things more descriptive names, where those names imply
+    # different defaults, like hexagon -> circle(sides: 6)
+    def oozby_alias from, to, **extra_args
+      define_method(from) do
+        call.named_args.merge!(extra_args) #{ |key,l,r| l } # left op wins conflicts
+        run_filters to
+        redirect to
+      end
+    end
+  end
+  
+  # never pass resolution data in to these methods - it's pointless:
+  NoResolution = %i(translate rotate scale mirror resize difference union
+                    intersection hull minkowski color)
+  # list of OpenSCAD standard methods - these can pass through without error:
+  DefaultOpenSCADMethods = %i(
+    cube sphere cylinder polyhedron
+    circle square polygon
+    scale resize rotate translate mirror multmatrix color minkowski hull
+    linear_extrude rotate_extrude import import_dxf projection
+    union difference intersection render
+  )
+  
+  attr_accessor :openscad_methods, :call
+  # setup a new method preprocessor
+  def initialize env: nil, ooz: nil
+    @env = env
+    @parent = ooz
+    @openscad_methods = DefaultOpenSCADMethods.dup
+  end
+  
+  # accepts an Oozby::Element and transforms it according to the processors' rules
+  def transform_call call_info
+    raise "call info isn't Oozby::Element #{call_info.inspect}" unless call_info.is_a? Oozby::Element
+    @call = call_info
+    original_method = @call.method
+    
+    run_filters call_info.method.to_sym
+    
+    methods = primary_processors
+    # if a primary processor is defined for this kind of call
+    if methods.include? call_info.method.to_sym
+      # call the primary processor
+      result = public_send(call_info.method, *primary_method_args)
+      
+      # replace the ast content with the processor's output
+      if result.is_a? Hash or result.is_a? Oozby::Element
+        # replace called item with this new stuff
+        return result
+      elsif result != nil # ignore nil - we don't need to do anything for that!
+        raise "#{original_method} preprocessor returned invalid result #{result.inspect}"
+      end
+    end
+    
+    return call_info
+  end
+  
+  def run_filters method_name
+    # apply the other filters
+    filters = self.class.filters_for(method_name)
+    filters.each do |filter_data|
+      filter_name, *filter_args = filter_data
+      send(filter_name, *filter_args)
+    end
+  end
+  
+  # generates argument list to call a primary method processor
+  def primary_method_args # :nodoc:
+    # grab the primary processor
+    primary = self.class.public_instance_method(call.method.to_sym)
+    params = primary.parameters
+    # parse the processor method's signature
+    param_names = params.select { |x| x.first == :key }.map { |x| x[1] }
+    # filter down args to only those requested
+    calling_args = call.named_args.dup
+    # convert unnamed call args to named args
+    calling_args.merge! args_parse(call, *param_names)
+    # delete any args the receiver can't handle
+    calling_args.delete_if { |k,v| not param_names.include?(k) }
+    if calling_args.empty? then [] else [calling_args] end
+  end
+  
+  # list of primary processor methods
+  def primary_processors
+    @primary_processors ||= public_methods(false) - @@system_methods
+  end
+  
+  # does this processor know of a method named whatever?
+  def known? name
+    known.include? name.to_sym
+  end
+  
+  # array of all known method names
+  def known
+    list = @openscad_methods.dup
+    list.push *primary_processors
+    list.push *@@method_filters.keys
+    list.uniq
+  end
+  
+  # rewrite this method to a different method name and primary processor and whatever else
+  def redirect new_method
+    call.method = new_method.to_sym
+    public_send(new_method, *primary_method_args) if self.respond_to? new_method
+  end
+  
+  
+  # parse arguments like openscad does
+  def args_parse(info, *arg_names)
+    args = info.named_args.dup
+    info.args.length.times do |index|
+      warn "Overwriting argument #{arg_names[index]}" if args.key? arg_names[index]
+      args[arg_names[index]] = info.args[index]
+    end
+    
+    args
+  end
+  
+  # capture contents of a block as openscad code, returning AST array
+  def capture &proc
+    env = @env
+    (env._subscope {
+      env.preprocessor(false) {
+        env._execute_oozby(&proc)
+      }
+    }).find { |x| x.is_a? Oozby::Element }
+  end
+  
+  # remember list of public methods defined so far - these are system ones
+  @@system_methods = public_instance_methods(false)
+end
+
+

data/lib/oozby/version.rb

@@ -1,5 +1,5 @@
 class Oozby
-  Version = '0.3.1'
+  Version = '0.4.0'
   
   def self.version
     Oozby::Version

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: oozby
 version: !ruby/object:Gem::Version
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Bluebie
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-29 00:00:00.000000000 Z
+date: 2013-10-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: listen
@@ -52,6 +52,20 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: 0.2.11
+- !ruby/object:Gem::Dependency
+  name: colored
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '1.2'
 description: OpenSCAD - a cad language for creating solid 3d objects, useful for CNC
   and 3D Printing, is incredibly annoying. It doesn't even support variables! Oozby
   is a markup builder like Markaby or XML Builder, so you can write OpenSCAD programs
@@ -67,7 +81,8 @@ files:
 - lib/oozby/base.rb
 - lib/oozby/element.rb
 - lib/oozby/environment.rb
-- lib/oozby/method_preprocessor.rb
+- lib/oozby/preprocessor-definitions.rb
+- lib/oozby/preprocessor.rb
 - lib/oozby/render.rb
 - lib/oozby/version.rb
 - lib/oozby.rb

data/lib/oozby/method_preprocessor.rb

@@ -1,362 +0,0 @@
-# The Oozby Method Preprocessor handles requests via the transform_call method
-# and transforms the Oozby::Element passed in, patching in any extra features
-# and trying to alert the user of obvious bugs
-
-
-class Oozby::MethodPreprocessor
-  # never pass resolution data in to these methods - it's pointless:
-  NoResolution = %i(translate rotate scale mirror resize difference union intersection hull minkowski color)
-  # list of OpenSCAD standard methods - these can pass through without error:
-  DefaultOpenSCADMethods = %i(
-    cube sphere cylinder polyhedron
-    circle square polygon
-    scale resize rotate translate mirror multmatrix color minkowski hull
-    linear_extrude rotate_extrude import projection
-    union difference intersection render
-  )
-  
-  attr_accessor :openscad_methods
-  # setup a new method preprocessor
-  def initialize env: nil, ooz: nil
-    @env = env
-    @parent = ooz
-    @openscad_methods = DefaultOpenSCADMethods.dup
-  end
-  
-  # accepts an Oozby::Element and transforms it according to the processors' rules
-  def transform_call(call_info)
-    send("_#{call_info.method}", call_info) if respond_to? "_#{call_info.method}"
-    resolution call_info unless NoResolution.include? call_info.method # apply resolution settings from scope
-    return call_info
-  end
-  
-  # does this processor know of a method named whatever?
-  def known? name
-    return true if respond_to? "_#{name}"
-    return @openscad_methods.include? name.to_sym
-  end
-  
-  # array of all known method names
-  def known
-    list = @openscad_methods.dup
-    list.push *public_methods(false).select { |method_name| method_name.to_s.start_with? '_' }.map { |x| x.to_s.sub(/_/, '').to_sym }
-    list.uniq
-  end
-  
-  # allow method to take x, y, z named args instead of array, with defaults to 0
-  def xyz_to_array(info, default: 0, arg: false, depth: true)
-    if [:x, :y, :z].any? { |name| info[:named_args].include? name }
-      
-      # create coordinate 'vector' (array)
-      if depth
-        coords = [
-          info[:named_args][:x] || default,
-          info[:named_args][:y] || default,
-          info[:named_args][:z] || default
-        ]
-      else
-        coords = [
-          info[:named_args][:x] || default,
-          info[:named_args][:y] || default
-        ]
-      end
-      
-      # if argument name is specified, use that, otherwise make it the first argument in the call
-      if arg
-        info[:named_args][arg] = coords
-      else
-        info[:args].unshift coords
-      end
-      
-      # delete unneeded bits from call
-      [:x, :y, :z].each { |item| info[:named_args].delete item }
-    end
-  end
-  
-  # layout defaults like {center: true}
-  def layout_defaults(info)
-    info[:named_args] = @env.defaults.dup.merge(info[:named_args])
-  end
-  
-  # apply resolution settings to element
-  ResolutionLookupTable = {degrees_per_fragment: :"$fa", minimum: :"$fs", fragments: :"$fn"}
-  def resolution(info)
-    res = @env.resolution
-    res.delete_if { |k,v| Oozby::Environment::ResolutionDefaults[k] == v }
-    res.each do |key, value|
-      info[:named_args][ResolutionLookupTable[key] || "$#{key}".to_sym] ||= value
-    end
-  end
-  
-  def _translate(info); xyz_to_array(info, arg: :v); end
-  def _rotate(info); xyz_to_array(info, arg: :a); end
-  def _scale(info); xyz_to_array(info, default: 1, arg: :v); end
-  def _mirror(info); xyz_to_array(info); end
-  def _resize(info); xyz_to_array(info, default: 1, arg: :newsize); end
-  def _cube(info)
-    xyz_to_array(info, default: 1, arg: :size)
-    expanded_names(info)
-    layout_defaults(info)
-    
-    if info.named_args[:r] && info.named_args[:r] > 0.0
-      # render rounded rectangle
-      info.replace rounded_cube(**args_parse(info, :size, :center))
-    end
-  end
-  
-  # general processing of arguments:
-  #  -o> Friendly names - use radius instead of r if you like
-  #  -o> Ranges - can specify radius: 5...10 instead of r1: 5, r2: 10
-  #  -o> Make h/height consistent (either works everywhere)
-  #  -o> Support inner radius, when number of sides is specified
-  #  -o> Specify diameter and have it halved automatically
-  def expanded_names(info, height_label: :h)
-    # let users use 'radius' as longhand for 'r'
-    info.named_args[:r]  = info.named_args.delete(:radius)   if info.named_args[:radius]
-    info.named_args[:r1] = info.named_args.delete(:radius1)  if info.named_args[:radius1]
-    info.named_args[:r1] = info.named_args.delete(:radius_1) if info.named_args[:radius_1]
-    info.named_args[:r2] = info.named_args.delete(:radius2)  if info.named_args[:radius2]
-    info.named_args[:r2] = info.named_args.delete(:radius_2) if info.named_args[:radius_2]
-    
-    info.named_args[:"$fn"] = info.named_args.delete(:facets) if info.named_args[:facets]
-    info.named_args[:"$fn"] = info.named_args.delete(:fragments) if info.named_args[:fragments]
-    info.named_args[:"$fn"] = info.named_args.delete(:sides) if info.named_args[:sides]
-    
-    info.named_args[:ir] = info.named_args.delete(:inr) if info.named_args[:inr]
-    info.named_args[:ir] = info.named_args.delete(:inradius) if info.named_args[:inradius]
-    info.named_args[:ir] = info.named_args.delete(:inner_r) if info.named_args[:inner_r]
-    info.named_args[:ir] = info.named_args.delete(:inner_radius) if info.named_args[:inner_radius]
-    
-    # let users specify diameter instead of radius - convert it
-    {  diameter: :r,                    dia: :r,               d: :r,
-      diameter1: :r1, diameter_1: :r1, dia1: :r1, dia_1: :r1, d1: :r1,
-      diameter2: :r2, diameter_2: :r2, dia2: :r2, dia_2: :r2, d2: :r2,
-      id: :ir, inner_diameter: :ir, inner_d: :ir,
-      id1: :ir1, inner_diameter_1: :ir1, inner_diameter1: :ir1,
-      id2: :ir2, inner_diameter_2: :ir2, inner_diameter2: :ir2
-    }.each do |d, r|
-      if info.named_args.key? d
-        data = info.named_args.delete(d)
-        if data.is_a? Range
-          data = Range.new(data.first / 2.0, data.last / 2.0, data.exclude_end?)
-        elsif data.respond_to? :to_f
-          data = data.to_f / 2.0
-        else
-          raise "#{data.inspect} must be Numeric or a Range"
-        end
-        info.named_args[r] = data
-      end
-    end
-    
-    # process 'inner radius' bits
-    { ir: :r, ir1: :r1, ir2: :r2 }.each do |ir, r|
-      if info.named_args.key? ir
-        sides = info.named_args[:"$fn"].to_i
-        raise "Use of inner radius requires sides/facets/fragments argument to #{info.method}()" unless sides
-        raise "Sides must be at least 3" unless sides >= 3
-        inradius = info.named_args.delete(ir)
-        if inradius.is_a? Range
-          circumradius = Range.new(inradius.first.to_f / @env.cos(180.0 / sides),
-                           inradius.first.to_f / @env.cos(180.0 / sides),
-                           inradius.exclude_end?)
-        elsif inradius.respond_to? :to_f
-          circumradius = inradius.to_f / @env.cos(180.0 / sides)
-        else
-          raise "#{inradius.inspect} must be Numeric or a Range"
-        end
-        info.named_args[r] = circumradius
-      end
-    end
-    
-    # allow range for radius
-    if info.named_args[:r].is_a? Range
-      range = info.named_args.delete(:r)
-      info.named_args[:r1] = range.first
-      info.named_args[:r2] = range.last
-    end
-    
-    # long version 'height' becomes 'h'
-    height_specification = info.named_args.delete(:height) || info.named_args.delete(:h)
-    info.named_args[height_label] = height_specification if height_specification
-  end
-  
-  def _linear_extrude(info); layout_defaults(info); expanded_names(info, height_label: :height); end
-  def _rotate_extrude(info); layout_defaults(info); expanded_names(info); end
-  
-  def _circle(info); expanded_names(info); end
-  def _sphere(info); expanded_names(info); end
-  def _cylinder(info); expanded_names(info); layout_defaults(info); end
-  def _square(info)
-    expanded_names(info)
-    xyz_to_array(info, default: 1, arg: :size, depth: false)
-    layout_defaults(info)
-    
-    if info[:named_args][:r] and info.named_args[:r] > 0.0
-      # render rounded rectangle
-      info.replace rounded_rect(**args_parse(info, :size, :center).merge(facets: info.named_args["$fn"]))
-    end
-  end
-  
-  def rounded_rect size: [1,1], center: false, r: 0.0, facets: nil
-    size = [size] * 2 if size.is_a? Numeric
-    diameter = r * 2
-    circle_x = (size[0] / 2.0) - r
-    circle_y = (size[1] / 2.0) - r
-    
-    capture do
-      resolution(fragments: (facets || 0)) do
-        translate(if center then [0,0] else [size[0].to_f / 2.0, size[1].to_f / 2.0] end) do
-          union do
-            square([size[0], size[1] - diameter], center = true)
-            square([size[0] - diameter, size[1]], center = true)
-            preprocessor true do
-              resolution(fragments: (_fragments_for(radius: r).to_f / 4.0).round * 4.0) do
-                translate([ circle_x,  circle_y]) { circle(r: r) }
-                translate([ circle_x, -circle_y]) { circle(r: r) }
-                translate([-circle_x, -circle_y]) { circle(r: r) }
-                translate([-circle_x,  circle_y]) { circle(r: r) }
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-  
-  def rounded_cube size: [1,1,1], center: false, r: 0.0, facets: nil
-    size = [size] * 3 if size.is_a? Numeric
-    size = [size[0] || 1, size[1] || 1, size[2] || 1]
-    diameter = r.to_f * 2.0
-    
-    preprocessor = self
-    # use rounded rect to create the body shape
-    capture do
-      resolution(fragments: (facets || 0)) do
-        offset = if center then [0,0,0] else [size[0].to_f / 2.0, size[1].to_f / 2.0, size[2].to_f / 2.0] end
-        translate(offset) do
-          # extrude the main body parts using rounded_rect as the basis
-          linear_extrude(height: size[2] - diameter, center: true) {
-            inject_abstract_tree(preprocessor.rounded_rect(size: [size[0], size[1]], center: true, r: r)) }
-          rotate([90,0,0]) { linear_extrude(height: size[1] - diameter, center: true) {
-            inject_abstract_tree(preprocessor.rounded_rect(size: [size[0], size[2]], center: true, r: r)) }}
-          rotate([0,90,0]) { linear_extrude(height: size[0] - diameter, center: true) {
-            inject_abstract_tree(preprocessor.rounded_rect(size: [size[2], size[1]], center: true, r: r)) }}
-        
-          # fill in the corners with spheres
-          xr, yr, zr = size.map { |x| (x / 2.0) - r }
-          corner_coordinates = [
-            [ xr, yr, zr],
-            [ xr, yr,-zr],
-            [ xr,-yr, zr],
-            [ xr,-yr,-zr],
-            [-xr, yr, zr],
-            [-xr, yr,-zr],
-            [-xr,-yr, zr],
-            [-xr,-yr,-zr]
-          ]
-          preprocessor true do
-            resolution(fragments: (_fragments_for(radius: r.to_f).to_f / 4.0).round * 4.0) do
-              corner_coordinates.each do |coordinate|
-                translate(coordinate) do
-                  # generate sphere shape
-                  rotate_extrude do
-                    intersection do
-                      circle(r: r)
-                      translate([r, 0, 0]) { square([r * 2.0, r * 4.0], center: true) }
-                    end
-                  end
-                end
-              end
-            end
-          end
-        end
-      end
-    end
-  end
-  
-  # parse arguments like openscad does
-  def args_parse(info, *arg_names)
-    args = info[:named_args].dup
-    info[:args].length.times do |index|
-      warn "Overwriting argument #{arg_names[index]}" if args.key? arg_names[index]
-      args[arg_names[index]] = info[:args][index]
-    end
-    
-    args
-  end
-  
-  def capture &proc
-    env = @env
-    (env._subscope {
-      env.preprocessor(false) {
-        env._execute_oozby(&proc)
-      }
-    }).first    
-  end
-  
-  # meta! construct aliases which preset some values
-  def self.oozby_alias from, to, extra_args = {}
-    define_method "_#{from}" do |info|
-      info.method = to
-      info.named_args.merge! extra_args
-      send("_#{to}", info) if self.respond_to? "_#{to}"
-    end
-  end
-  
-  # some regular shapes - from:
-  # http://en.wikipedia.org/wiki/Regular_polygon#Regular_convex_polygons
-  polygon_names = {
-    triangle: 3,
-    equilateral_triangle: 3,
-    pentagon: 5,
-    hexagon: 6,
-    heptagon: 7,
-    octagon: 8,
-    nonagon: 9,
-    enneagon: 9,
-    decagon: 10,
-    hendecagon: 11,
-    undecagon: 11,
-    dodecagon: 12,
-    tridecagon: 13,
-    tetradecagon: 14,
-    pentadecagon: 15,
-    hexadecagon: 16,
-    heptadecagon: 17,
-    octadecagon: 18,
-    enneadecagon: 19,
-    icosagon: 20,
-    triacontagon: 30,
-    tetracontagon: 40,
-    pentacontagon: 50,
-    hexacontagon: 60,
-    heptacontagon: 70,
-    octacontagon: 80,
-    enneacontagon: 90,
-    hectogon: 100
-  }
-  polygon_names.each do |shape_name, sides|
-    oozby_alias shape_name, :circle, sides: sides
-  end
-  
-  # make a polygon with an arbitrary number of sides
-  oozby_alias :ngon, :circle, sides: 3
-  # make a prism with an arbitrary number of sides
-  oozby_alias :prism, :cylinder, sides: 3
-  
-  # triangles are an edge case
-  oozby_alias :triangular_prism, :cylinder, sides: 3
-  
-  # for all the rest, transform the prism names automatically
-  polygon_names.each do |poly_name, sides|
-    name = poly_name.to_s
-    if name.end_with? 'gon'
-      name += 'al_prism'
-      oozby_alias name, :cylinder, sides: sides
-    end
-  end
-end
-
-
-
-