arbol 0.0.2

data/lib/builder.rb

@@ -0,0 +1,102 @@
+require 'json'
+require 'pp'
+require 'erb'
+
+require_relative 'base.rb'
+
+# module used to handle the global class map
+module Arbol
+  @@class_map = {}
+
+  def self.class_map
+    @@class_map
+  end
+
+  def self.add_mapped_class(type, mapped_class, code)
+    @@class_map[type] = mapped_class
+    @@libs << code if code
+  end
+
+  @@libs = []
+
+  def self.libs
+    @@libs
+  end
+end
+
+# new instance of the class specified by params[:type]
+def builder(params)
+  # puts params
+  Arbol.class_map[params[:type]].new(params)
+end
+
+def custom_arduino_script_body(structure)
+  ref_builders = []
+  structure[:refs].each do |ref|
+    this_ref = builder(
+      ref
+    )
+    this_ref.resolve_frame_optimized
+    ref_builders << this_ref
+  end
+
+  # run the builder
+  t = builder(
+    structure[:calc]
+  )
+  
+  t.resolve_frame_optimized
+  
+  # create a tsortable hash and populate it with the nodes
+  ts = TsortableHash.new
+
+  # first append the ref nodes
+  ref_builders.each { |r| r.append_tsortable(ts) }
+
+  # then append the primary calc nodes
+  t.append_tsortable(ts)
+
+  # creates a hash containing all the code keyed by node name
+  pixel_scope_code = {}
+  
+  # creates an hash of code for top_level_scope declarations
+  top_level_scope_code = {}
+  
+  # contains cycle level code
+  cycle_scope_code = {}
+
+  # first append the ref nodes
+  ref_builders.each { |r| r.add_arduino_code(pixel_scope_code) }
+  ref_builders.each { |r| r.add_cycle_level_scope(cycle_scope_code) }
+  ref_builders.each { |r| r.add_top_level_scope(top_level_scope_code) }
+   
+  # then the primary calc nodes
+  t.add_arduino_code(pixel_scope_code)
+  t.add_cycle_level_scope(cycle_scope_code)
+  t.add_top_level_scope(top_level_scope_code)
+
+  pixel_scope = []
+  top_level_scope = []
+  cycle_scope = []
+  # run tsort... then append the lines of code in the order they should be executed
+  t = ts.tsort
+  t.each do |func|
+    pixel_scope_code[func].each do |stmt|
+      pixel_scope << stmt
+    end
+    
+    cycle_scope_code[func].each do |stmt|
+      cycle_scope << stmt
+    end
+    
+    top_level_scope_code[func].each do |stmt|
+      top_level_scope << stmt
+    end
+  end
+
+  # last output needs to be passed to the strip
+  pixel_scope << ''
+  pixel_scope << "// output"
+  pixel_scope << "strip.setPixelColor(i, (byte)long_mult(255, #{t.last}[0]), (byte)long_mult(255, #{t.last}[1]), (byte)long_mult(255, #{t.last}[2]));"
+  return top_level_scope, cycle_scope, pixel_scope
+end

data/lib/documentation.rb

@@ -0,0 +1,19 @@
+module Arbol
+  class Documentation
+    def output_all_documentation
+      (self.public_methods - Object.public_methods).sort.each do |m|
+        unless [:output_all_documentation, :output_single_doc].include? m.to_sym
+          output_single_doc(m) 
+        end
+      end   
+    end
+    
+    def output_single_doc(func)
+      puts(
+        self.send(
+          func.to_sym
+        )
+      )
+    end
+  end
+end

data/lib/dsl.rb

@@ -0,0 +1,168 @@
+# scales float values to the integer scale representation.
+# @param [Float|Integer] val
+# @return [Integer]
+def scale_correctly(val)
+  case
+    when val.class == Integer then return val
+    when val.class == Float then return (val * 8192).to_i
+  end
+end
+
+# resolves an input object to a structure appropriate for the tree.
+# @param [Object] val
+# @return [Object]
+def resolve(val)
+  case
+    when val.class == Integer then return my_const(scale_correctly(val))
+    when val.class == Float then return my_const(scale_correctly(val))
+    when val.class == Array then return my_const(
+      val.map { |i| scale_correctly(i) }
+    )
+    when val.class == ArbolHash then return val
+  end
+end
+
+def resolve_lookup_table(val)
+  val.map { |v| resolve(val) }
+end
+
+def resolve_integer(val)
+  if val.class == Integer
+    val
+  else
+    raise "#{val} is not an integer"
+  end
+end
+
+def resolve_float(val)
+  if val.class == Float
+    val
+  else
+    raise "#{val} is not an float"
+  end
+end
+
+def resolve_positive_scalar(val)
+  if [Integer, Float].include?(val.class)
+    if val >= 0
+      scale_correctly(val)
+    else
+      raise "#{} val should be positive"
+    end
+  else
+    raise "#{val} must be a positive scalar number"
+  end
+end
+
+def resolve_pin_reference(val)
+  if val.match(/(^A\d+$|^\d+$)/)
+    val
+  else
+    raise "#{val} is not a valid pin reference"
+  end
+end
+
+# coerces a scalar value to an array of 3 elements.
+# @param [Object] input
+# @return [Array]
+def coerce_array(input)
+  if input.class == Array
+    input
+  else
+    [input, input, input]
+  end
+end
+
+# top level object to create a neopixel strip
+# @param [Integer] lamps
+# @param [Integer] pin
+# @param [ArbolHash] calc
+# @return [Hash]
+def strip(lamps, pin, calc)
+  {
+    type: 'physical_strip',
+    lamps: lamps,
+    pin: pin,
+    calc: resolve(calc)
+  }
+end
+
+# removes comments from the dsl script
+# @param [String] script
+# @return [String]
+def remove_comments(script)
+  t = []
+  script.split("\n").each do |line|
+    if line.match(/\#/)
+      t << line.split('#',2)[0]
+    else
+      t << line
+    end
+  end
+  t.join("\n")
+end
+
+# separates declarations by ; delimiter
+# @param [String] script
+# @return [Array<String>]
+def script_split(script)
+  script.split(';').select { |l| l.strip != '' }
+end
+
+# converts an array of statements to an arbol tree structure
+# @param [Array<String>] stmts
+# @param [Binding] scope
+# @param [Hash]
+def stmts_to_structure(stmts, scope)
+  # defined references that can be used in the script
+  refs = []
+  # injection of ruby code into the eval
+  # starts with the refinement, but refs will be added
+  refinjects = ['using RefineBasics; ']
+
+  # iterate all of the statements. last statement must be a strip definition
+  stmts.each do |stmt|
+    # ref handling
+    if stmt.match(/(\w|\s)+={1}(\w|\s)+/)
+      ref_name = stmt.match(/\w+/)[0]
+      statements = "#{refinjects.join('')}#{stmt.split('=', 2)[1]}"
+      this_ref = create_ref(
+        ref_name,
+        eval(statements, scope)
+      )
+      refinject = "#{ref_name} = ref('#{ref_name}');"
+      refs << this_ref
+      refinjects << refinject
+    # strip handling
+    elsif stmt.match('strip')
+      statements = "#{refinjects.join('')} #{stmt}"
+      retval = eval(statements, scope)
+      retval[:refs] = refs
+      return retval
+    end
+  end
+end
+
+# converts dsl text to an arbol tree structure
+# @param [String] script_text
+# @param [Binding] scope
+def interpret_dsl(script_text, scope)
+  stmts_to_structure(
+    script_split(
+      remove_comments(
+        script_text
+      )
+    ),
+    scope
+  )
+end
+
+# converts a json string to an arbol tree structure
+# @param [String] json_text
+# @return [Hash]
+def interpret_json(json_text)
+  JSON.parse(
+    json_text,
+    symbolize_names: true
+  )
+end

data/lib/functions/add.rb

@@ -0,0 +1,70 @@
+class Add < Base
+  Arbol.add_mapped_class(
+    'add', 
+    Add,
+%{void add(long op1[3], long op2[3], long out[3]) {
+  out[0] = op1[0] + op2[0];
+  out[1] = op1[1] + op2[1];
+  out[2] = op1[2] + op2[2];
+}}
+  )
+  
+  attr_accessor :op1
+  attr_accessor :op2
+  
+  def param_keys
+    [:op1, :op2]
+  end
+
+  def arduino_code
+    unless @frame_optimized 
+      [
+        "add(#{@op1.name}, #{@op2.name}, #{@name});"
+      ]
+    else
+      []
+    end
+  end
+  
+  def cycle_level_arduino_code
+    if @frame_optimized
+      [
+        "add(#{@op1.name}, #{@op2.name}, #{@name});"
+      ]
+    else
+      []
+    end
+  end
+  
+  def top_level_scope_code
+    [
+      "long #{@name}[3];",
+    ]
+  end
+end
+
+module Arbol
+  class Documentation
+
+  def add   
+%{--
+### add(op1, op2)
+
+* **op1** - operator1
+* **op2** - operator2
+
+Adds op1 and op2. can also be used in the form `op1 + op2`.
+
+}
+  end
+
+  end
+end
+
+def add(op1, op2)
+  h = ArbolHash.new
+  h[:type] = 'add'
+  h[:op1] = resolve(op1)
+  h[:op2] = resolve(op2)
+  h
+end

data/lib/functions/add_constrain.rb

@@ -0,0 +1,70 @@
+class AddConstrain < Base
+  Arbol.add_mapped_class(
+    'add_constrain', 
+    AddConstrain,
+%{void add_constrain(long op1[3], long op2[3], long out[3]) {
+  out[0] = constrain(op1[0] + op2[0], 0, INTEGER_SCALE);
+  out[1] = constrain(op1[1] + op2[1], 0, INTEGER_SCALE);
+  out[2] = constrain(op1[2] + op2[2], 0, INTEGER_SCALE);
+}}
+  )
+  
+  attr_accessor :op1
+  attr_accessor :op2
+  
+  def param_keys
+    [:op1, :op2]
+  end
+
+  def arduino_code
+    unless @frame_optimized 
+      [
+        "add_constrain(#{@op1.name}, #{@op2.name}, #{@name});"
+      ]
+    else
+      []
+    end
+  end
+  
+  def cycle_level_arduino_code
+    if @frame_optimized
+      [
+        "add_constrain(#{@op1.name}, #{@op2.name}, #{@name});"
+      ]
+    else
+      []
+    end
+  end
+  
+  def top_level_scope_code
+    [
+      "long #{@name}[3];"
+    ]
+  end
+end
+
+module Arbol
+  class Documentation
+
+def add_constrain    
+%{--
+### add\_constrain(op1, op2)
+
+* **op1** - operator1
+* **op2** - operator2
+
+Adds op1 and op2, then constrains the result between 0.0-~1.0.
+
+}
+end
+
+  end
+end
+
+def add_constrain(op1, op2)
+  h = ArbolHash.new
+  h[:type] = 'add_constrain'
+  h[:op1] = resolve(op1)
+  h[:op2] = resolve(op2)
+  h
+end

data/lib/functions/add_modulo.rb

@@ -0,0 +1,70 @@
+class AddModulo < Base
+  Arbol.add_mapped_class(
+    'add_modulo', 
+    AddModulo,
+%{void add_modulo(long op1[3], long op2[3], long out[3]) {
+  out[0] = (op1[0] + op2[0]) % INTEGER_SCALE;
+  out[1] = (op1[1] + op2[1]) % INTEGER_SCALE;
+  out[2] = (op1[2] + op2[2]) % INTEGER_SCALE;
+}}
+  )
+  
+  attr_accessor :op1
+  attr_accessor :op2
+  
+  def param_keys
+    [:op1, :op2]
+  end
+
+  def arduino_code
+    unless @frame_optimized 
+      [
+        "add_modulo(#{@op1.name}, #{@op2.name}, #{@name});"
+      ]
+    else
+      []
+    end
+  end
+  
+  def cycle_level_arduino_code
+    if @frame_optimized
+      [
+        "add_modulo(#{@op1.name}, #{@op2.name}, #{@name});"
+      ]
+    else
+      []
+    end
+  end
+  
+  def top_level_scope_code
+    [
+      "long #{@name}[3];",
+    ]
+  end
+end
+
+module Arbol
+  class Documentation
+
+def add_modulo   
+%{--
+### add\_modulo(op1, op2)
+
+* **op1** - operator1
+* **op2** - operator2
+
+Adds op1 and op2, then returns the result modulo 1.0.
+
+}
+end
+
+  end
+end
+
+def add_modulo(op1, op2)
+  h = ArbolHash.new
+  h[:type] = 'add_modulo'
+  h[:op1] = resolve(op1)
+  h[:op2] = resolve(op2)
+  h
+end