delorean_lang 0.0.34 → 0.0.38

data/lib/delorean/delorean.treetop

@@ -10,27 +10,33 @@ grammar Delorean
     /
     sp i:identifier sp? '=' sp? e:expression <Formula>
     /
-    n:node_name ':' sp? mod:(m:node_name '::')? p:node_name <SubNode>
+    n:class_name ':' sp? mod:(m:class_name '::')? p:class_name <SubNode>
     /
-    n:node_name ':' <BaseNode>
+    n:class_name ':' <BaseNode>
     /
-    'import' sp n:node_name sp v:integer <Import>
+    'import' sp n:class_name sp v:integer <Import>
   end
 
-  rule node_name
+  rule class_name
     [A-Z] [a-zA-Z0-9_]*
   end
 
   rule expression
     op:unary_op sp? e:expression <UnOp>
     /
-    'if' sp? v:expression sp?
-    'then' sp? e1:expression sp?
-    'else' sp? e2:expression <IfElse>
+    'if' 	sp? v:expression sp?
+    'then' 	sp? e1:expression sp?
+    'else' 	sp? e2:expression <IfElse>
+    /
+    v:getattr_exp sp? op:binary_op sp? e:expression <BinOp>
     /
-    v:value sp? op:binary_op sp? e:expression <BinOp>
+    v:getattr_exp sp? '[' sp? args:fn_args sp? ']' <IndexOp>
     /
-    value
+    getattr_exp
+  end
+
+  rule getattr_exp
+    v:value ga:(('.' identifier)*) <ExpGetAttr>
   end
 
   rule list_expr
@@ -47,6 +53,11 @@ grammar Delorean
   rule hash_expr
     '{}' <HashExpr>
     /
+    '{' sp? el:expression sp? ':' sp? er:expression sp
+        'for' sp i:identifier sp 'in' sp e1:expression sp?
+        ifexp:('if' sp ei:expression sp?)?
+    '}' <HashComprehension>
+    /
     '{' sp? args:hash_args sp? '}' <HashExpr>
   end
 
@@ -61,26 +72,23 @@ grammar Delorean
   end
 
   rule value
-    number 		/
-    string 		/ 
-    boolean 		/ 
-    nil_val		/
-    script_call 	/ 
-    fn 			/ 
-    model_fn_getattr 	/
-    model_fn 		/ 
-    node_getattr 	/ 
-    getattr 		/
-    list_expr 		/
-    hash_expr 		/
-    '(' sp? e:expression sp? ')' <Expr>
+    number 						/
+    string 						/ 
+    boolean 						/ 
+    nil_val						/
+    script_call 					/ 
+    fn 							/ 
+    model_fn 						/ 
+    identifier						/
+    list_expr 						/
+    hash_expr 						/
+    mod:(m:class_name '::')? c:class_name <NodeAsValue> 	/
+    '(' sp? e:expression sp? ')' 	 <Expr>
   end
 
   # built-in functions
   rule fn
-    fn:fn_name '(' sp? ')' <Fn>
-    /
-    fn:fn_name '(' sp? args:fn_args sp? ')' <Fn>
+    fn:fn_name '(' sp? args:fn_args? sp? ')' <Fn>
   end
 
   rule fn_args
@@ -94,22 +102,16 @@ grammar Delorean
   end
 
   rule model_name
-    class_name '::' model_name
-    /
-    class_name
+    class_name ('::' model_name)?
   end
 
   rule fn_name
     [A-Z] [A-Z0-9]*
   end
 
-  rule class_name
-    [A-Z] [a-zA-Z0-9]*
-  end
-
   # script calling
   rule script_call
-    '@' mod:(m:node_name '::')? c:class_name '(' sp? al:kw_args sp? ')' <ScriptCallNode>
+    '@' mod:(m:class_name '::')? c:class_name '(' sp? al:kw_args sp? ')' <ScriptCallNode>
     /
     '@' i:identifier? '(' sp? al:kw_args sp? ')' <ScriptCall>
   end
@@ -122,20 +124,6 @@ grammar Delorean
     k:(i:identifier ':' sp?)? arg0:expression args_rest:(sp? ',' sp? al:kw_args)? <KwArgs>
   end
 
-  rule node_getattr
-    n:node_name '.' i:identifier <NodeGetAttr>
-  end
-
-  rule model_fn_getattr
-    mfn:model_fn '.' i:identifier <ModelFnGetAttr>
-  end
-
-  rule getattr
-    i:identifier '.' ga:getattr <GetAttr>
-    /
-    identifier
-  end
-
   rule number
     decimal / integer
   end

data/lib/delorean/engine.rb

@@ -1,10 +1,7 @@
+require 'delorean/const'
 require 'delorean/base'
 
 module Delorean
-  SIG = "_SIG"
-  MOD = "DELOREAN__"
-  POST = "__D"
-
   class Engine
     attr_reader :last_node, :module_name, :line_no, :comp_set, :pm, :m, :imports
 
@@ -281,24 +278,36 @@ module Delorean
 
     # enumerate all nodes
     def enumerate_nodes
-      n = SortedSet.new
-      @node_attrs.keys.each {|k| n.add(k) }
-      n
+      SortedSet[* @node_attrs.keys]
     end
 
     # enumerate qualified list of all attrs
     def enumerate_attrs
-      enumerate_attrs_by_node(nil)
+      @node_attrs.keys.inject({}) { |h, node|
+        h[node] = enumerate_attrs_by_node(node)
+        h
+      }
     end
 
-    # enumerate qualified list of attrs by node (or all if nil is passed in)
+    # enumerate qualified list of attrs by node
     def enumerate_attrs_by_node(node)
-      @node_attrs.keys.inject({}) { |h, n|
-        klass = @m.module_eval(n)
-        h[n] = klass.methods.map(&:to_s).select {|x| x.end_with?(POST)}.map {|x|
-          x.sub(/#{POST}$/, '')
-        } if node == n || node.nil?
-        h
+      raise "bad node" unless node
+
+      # FIXME: for some reason, in rspec we get nodes which are String
+      # but .is_a?(String) fails.
+      begin
+        klass = node.class.name=="String" ? @m.module_eval(node) : node
+      rescue NameError
+        # FIXME: a little hacky.  Should raise an exception.
+        return []
+      end
+
+      raise "bad node class #{klass}" unless klass.is_a?(Class)
+
+      klass.methods.map(&:to_s).select { |x|
+        x.end_with?(POST)
+      }.map { |x|
+        x.sub(/#{POST}$/, '')
       }
     end
 
@@ -310,9 +319,7 @@ module Delorean
     # enumerate params by a single node
     def enumerate_params_by_node(node)
       attrs = enumerate_attrs_by_node(node)
-      ps = Set.new
-      attrs.each_value {|v| v.map {|p| ps.add(p) if @param_set.include?(p.to_s)}}
-      ps
+      Set.new( attrs.select {|a| @param_set.include?(a)} )
     end
 
     ######################################################################
@@ -323,18 +330,29 @@ module Delorean
       evaluate_attrs(node, [attr], params)[0]
     end
 
+    def evaluate_attrs_hash(node, attrs, params={})
+      res = evaluate_attrs(node, attrs, params)
+      Hash[* attrs.zip(res).flatten(1)]
+    end
+
     def evaluate_attrs(node, attrs, params={})
-      raise "bad node '#{node}'" unless node =~ /^[A-Z][a-zA-Z0-9_]*$/
+      raise "bad params" unless params.is_a?(Hash)
 
-      begin
-        klass = @m.module_eval(node)
-      rescue NameError
-        err(UndefinedNodeError, "node #{node} is undefined")
+      if node.is_a?(Class)
+        klass = node
+      else
+        raise "bad node '#{node}'" unless node =~ /^[A-Z][a-zA-Z0-9_]*$/
+
+        begin
+          klass = @m.module_eval(node)
+        rescue NameError
+          err(UndefinedNodeError, "node #{node} is undefined")
+        end
       end
 
       params[:_engine] = self
 
-      attrs.map {|attr|
+      attrs.map { |attr|
         raise "bad attribute '#{attr}'" unless attr =~ /^[a-z][A-Za-z0-9_]*$/
         klass.send("#{attr}#{POST}".to_sym, params)
       }
@@ -355,5 +373,4 @@ module Delorean
     ######################################################################
 
   end
-
 end

data/lib/delorean/functions.rb

@@ -1,8 +1,9 @@
 module Delorean
   module Functions
+
     ######################################################################
 
-    def MAX(*args)
+    def MAX(_e, *args)
       args.max
     end
 
@@ -10,7 +11,7 @@ module Delorean
 
     ######################################################################
 
-    def MIN(*args)
+    def MIN(_e, *args)
       args.min
     end
 
@@ -18,14 +19,14 @@ module Delorean
 
     ######################################################################
 
-    def MAXLIST(arg)
+    def MAXLIST(_e, arg)
       raise "argument must be list" unless arg.is_a? Array
       arg.max
     end
 
     MAXLIST_SIG = [ 1, 1 ]
 
-    def MINLIST(arg)
+    def MINLIST(_e, arg)
       raise "argument must be list" unless arg.is_a? Array
       arg.min
     end
@@ -34,7 +35,7 @@ module Delorean
 
     ######################################################################
 
-    def ROUND(number, *args)
+    def ROUND(_e, number, *args)
       number.round(*args)
     end
 
@@ -42,7 +43,27 @@ module Delorean
 
     ######################################################################
 
-    def TIMEPART(time, part)
+    def NUMBER(_e, s)
+      return s if s.is_a?(Float) || s.is_a?(Fixnum)
+      raise "Can't convert #{s} to number" unless
+        s =~ /^\d+(\.\d+)?$/
+      
+      s.to_f
+    end
+
+    NUMBER_SIG = [ 1, 1 ]
+
+    ######################################################################
+
+    def STRING(_e, obj)
+      obj.to_s
+    end
+
+    STRING_SIG = [ 1, 1 ]
+
+    ######################################################################
+
+    def TIMEPART(_e, time, part)
       if time == Float::INFINITY
         return time if part == "d"
         raise "Can only access date part of Infinity"
@@ -50,58 +71,54 @@ module Delorean
 
       raise "non-time arg to TIMEPART" unless time.is_a?(Time)
       
-      return time.hour if part == "h"
-      return time.min if part == "m"
-      return time.sec if part == "s"
-      return time.to_date if part == "d"
-
-      raise "unknown part arg to TIMEPART"
+      case part
+      when "h" then time.hour
+      when "m" then time.min
+      when "s" then time.sec
+      when "d" then time.to_date
+      else
+        raise "unknown part arg to TIMEPART"
+      end
     end
 
     TIMEPART_SIG = [ 2, 2 ]
 
     ######################################################################
 
-    def DATEPART(date, part)
+    def DATEPART(_e, date, part)
       raise "non-date arg to DATEPART" unless date.is_a?(Date)
 
-      return date.month if part == "m"
-      return date.day if part == "d"
-      return date.year if part == "y"
-
-      raise "unknown part arg to DATEPART"
+      case part
+      when "m" then date.month
+      when "d" then date.day
+      when "y" then date.year
+      else
+        raise "unknown part arg to DATEPART"
+      end
     end
 
     DATEPART_SIG = [ 2, 2 ]
 
     ######################################################################
 
-    def DATEADD(date, interval, part)
+    def DATEADD(_e, date, interval, part)
       raise "non-date arg to DATEADD" unless date.is_a?(Date)
       raise "non-integer interval arg to DATEADD" unless interval.is_a?(Fixnum)
 
-      return date >> interval if part == "m"
-      return date + interval if part == "d"
-      return date >> (interval * 12) if part == "y"
-
-      raise "unknown part arg to DATEADD"
+      case part
+      when "m" then date >> interval
+      when "d" then date + interval
+      when "y" then date >> (interval * 12)
+      else
+        raise "unknown part arg to DATEADD"
+      end
     end
 
     DATEADD_SIG = [ 3, 3 ]
 
     ######################################################################
 
-    def INDEX(array, i)
-      raise "non-array arg to INDEX" unless array.is_a?(Array)
-      raise "non-integer index on call to INDEX" unless i.is_a?(Fixnum)
-      array.at(i)
-    end
-
-    INDEX_SIG = [ 2, 2 ]
-
-    ######################################################################
-
-    def FLATTEN(array, *args)
+    def FLATTEN(_e, array, *args)
       raise "non-array arg to FLATTEN" unless array.is_a?(Array)
       raise "non-integer flatten on call to FLATTEN" unless
         (args.empty? || args[0].is_a?(Fixnum))
@@ -112,7 +129,7 @@ module Delorean
 
     ######################################################################
 
-    def ERR(*args)
+    def ERR(_e, *args)
       str = args.map(&:to_s).join(", ")
       raise str
     end
@@ -121,14 +138,5 @@ module Delorean
 
     ######################################################################
 
-    def TOSYM(s)
-      # raise "non-String arg to SYM" unless s.is_a?(String)
-      s.to_sym
-    end
-
-    TOSYM_SIG = [ 1, 1 ]
-
-    ######################################################################
-
   end
 end

data/lib/delorean/model.rb

@@ -1,3 +1,5 @@
+require 'delorean/const'
+
 module Delorean
   module Model
     def self.included(base)
@@ -17,7 +19,7 @@ module Delorean
         if sig
           sig = [sig, sig] if sig.is_a? Fixnum
           raise "Bad signature" unless (sig.is_a? Array and sig.length==2)
-          self.const_set(name.to_s.upcase+SIG, sig)
+          self.const_set(name.to_s.upcase+Delorean::SIG, sig)
         end
       end
     end

data/lib/delorean/nodes.rb

@@ -80,7 +80,6 @@ eos
   class SubNode < SNode
     def check(context, *)
       mname = mod.m.text_value if defined?(mod.m)
-        
       context.parse_define_node(n.text_value, p.text_value, mname)
     end
 
@@ -117,6 +116,20 @@ eos
     end
   end
 
+  class NodeAsValue < SNode
+    def check(context, *)
+      mname = mod.m.text_value if defined?(mod.m)
+      context.parse_check_defined_mod_node(c.text_value, mname)
+      []
+    end
+
+    def rewrite(context)
+      node_name = c.text_value
+      mname = mod.m.text_value if defined?(mod.m)
+      context.super_name(node_name, mname)
+    end
+  end
+
   # unary operator
   class UnOp < SNode
     def check(context, *)
@@ -140,6 +153,17 @@ eos
     end
   end
 
+  class IndexOp < SNode
+    def check(context, *)
+      vc, ac = v.check(context), args.check(context)
+      ac + vc
+    end
+
+    def rewrite(context)
+      "_index(#{v.rewrite(context)}, [#{args.rewrite(context)}], _e)"
+    end
+  end
+
   class Literal < SNode
     def check(context, *)
       []
@@ -175,36 +199,19 @@ eos
     end
   end
 
-  class NodeGetAttr < SNode
-    def check(context, *)
-      context.parse_call_attr(n.text_value, i.text_value)
-      [text_value]
-    end
-
-    def rewrite(context)
-      text_value + POST + '(_e)'
-    end
-  end
-
-  class GetAttr < SNode
+  class ExpGetAttr < SNode
     def check(context, *)
-      i.check(context)
+      v.check(context)
     end
 
     def rewrite(context)
       attr_list = ga.text_value.split('.')
-      attr_list.inject(i.rewrite(context)) {|x, y| "_get_attr(#{x}, '#{y}')"}
-    end
-  end
 
-  class ModelFnGetAttr < SNode
-    def check(context, *)
-      mfn.check(context)
-    end
+      # If ga.text_value is not "", then we need to drop the 1st
+      # element since it'll be "".
+      attr_list.shift
 
-    def rewrite(context)
-      x = mfn.rewrite(context)
-      "_get_attr(#{x}, '#{i.text_value}')"
+      attr_list.inject(v.rewrite(context)) {|x, y| "_get_attr(#{x}, '#{y}', _e)"}
     end
   end
 
@@ -218,7 +225,7 @@ eos
     end
 
     def rewrite(context)
-      fn.text_value + "(" + (defined?(args) ? args.rewrite(context) : "") + ")"
+      fn.text_value + "(_e, " + (defined?(args) ? args.rewrite(context) : "") + ")"
     end
   end
 
@@ -297,13 +304,46 @@ eos
     end
 
     def rewrite(context)
-      res = "(#{e1.rewrite(context)}).map{"
+      res = "(#{e1.rewrite(context)})"
       context.parse_define_var(i.text_value)
-      res += "|#{i.rewrite(context)}| (#{e2.rewrite(context)}) }"
-
       res += ".select{|#{i.rewrite(context)}| (#{ifexp.e3.rewrite(context)}) }" if
         defined?(ifexp.e3)
+      res += ".map{"
+      res += "|#{i.rewrite(context)}| (#{e2.rewrite(context)}) }"
+      context.parse_undef_var(i.text_value)
+      res
+    end
+  end
 
+  class HashComprehension < SNode
+    def check(context, *)
+      vname = i.text_value
+
+      e1c = e1.check(context)
+      context.parse_define_var(vname)
+      # need to check el/er/ei in a context where the comprehension var
+      # is defined.
+      elc = el.check(context)
+      erc = er.check(context)
+      eic = defined?(ifexp.ei) ? ifexp.ei.check(context) : []
+
+      context.parse_undef_var(vname)
+      elc.delete(vname)
+      erc.delete(vname)
+      eic.delete(vname)
+
+      e1c + elc + erc + eic
+    end
+
+    def rewrite(context)
+      res = "(#{e1.rewrite(context)})"
+      context.parse_define_var(i.text_value)
+      iw = i.rewrite(context)
+      res += ".select{|#{iw}| (#{ifexp.ei.rewrite(context)}) }" if
+        defined?(ifexp.ei)
+      res += ".inject({}){"
+      res += "|_h#{iw}, #{iw}| "+
+        "_h#{iw}[#{el.rewrite(context)}]=(#{er.rewrite(context)}); _h#{iw}}"
       context.parse_undef_var(i.text_value)
       res
     end