delorean_lang 0.0.43 → 0.1.00

data/lib/delorean/delorean.treetop

@@ -22,6 +22,8 @@ grammar Delorean
   end
 
   rule expression
+    'ERR(' sp? args:fn_args sp? ')' <ErrorOp>
+    /
     op:unary_op sp? e:expression <UnOp>
     /
     'if' 	sp? v:expression sp?
@@ -30,13 +32,27 @@ grammar Delorean
     /
     v:getattr_exp sp? op:binary_op sp? e:expression <BinOp>
     /
-    v:getattr_exp sp? '[' sp? args:fn_args sp? ']' <IndexOp>
-    /
     getattr_exp
   end
 
   rule getattr_exp
-    v:value ga:(('.' identifier)*) <ExpGetAttr>
+    v:value dotted:dotted <GetattrExp>
+    /
+    value
+  end
+
+  rule dotted
+    d:dot_exp d_rest:dotted? <Dotted>
+  end
+
+  rule dot_exp
+    '[' sp? args:fn_args sp? ']' <IndexOp>
+    /
+    '(' sp? al:kw_args? sp? ')' <NodeCall>
+    /
+    '.' sp? i:identifier '(' sp? al:kw_args? sp? ')' <Call>
+    /
+    '.' sp? i:identifier <GetAttr>
   end
 
   rule list_expr
@@ -73,49 +89,20 @@ grammar Delorean
 
   rule value
     number 						/
-    string 						/ 
-    boolean 						/ 
+    string 						/
+    boolean 						/
     nil_val						/
-    script_call 					/ 
-    fn 							/ 
-    model_fn 						/ 
     identifier						/
     list_expr 						/
     hash_expr 						/
-    mod:(m:class_name '::')? c:class_name <NodeAsValue> 	/
+    mod:(m:class_name '::')? c:class_name <NodeAsValue> /
     '(' sp? e:expression sp? ')' 	 <Expr>
   end
 
-  # built-in functions
-  rule fn
-    fn:fn_name '(' sp? args:fn_args? sp? ')' <Fn>
-  end
-
   rule fn_args
     arg0:expression args_rest:(sp? ',' sp? args:fn_args?)? <FnArgs>
   end
 
-  rule model_fn
-    m:model_name '.' fn:identifier '(' sp? ')' <ModelFn>
-    /
-    m:model_name '.' fn:identifier '(' sp? args:fn_args sp? ')' <ModelFn>
-  end
-
-  rule model_name
-    class_name ('::' model_name)?
-  end
-
-  rule fn_name
-    [A-Z] [A-Z0-9]*
-  end
-
-  # script calling
-  rule script_call
-    '@' mod:(m:class_name '::')? c:class_name '(' sp? al:kw_args sp? ')' <ScriptCallNode>
-    /
-    '@' i:identifier? '(' sp? al:kw_args sp? ')' <ScriptCall>
-  end
-
   rule hash_args
     e0:expression sp? ':' sp? e1:expression args_rest:(sp? ',' sp? al:hash_args?)? <HashArgs>
   end
@@ -153,8 +140,8 @@ grammar Delorean
   end
 
   rule string
-    '"' ('\"' / !'"' .)* '"' <String>
+    '"' ('\"' / !'"' .)* '"' <DString>
     /
-    "'" [^']* "'" <String>
+    "'" [^']* "'" <DString>
   end
 end

data/lib/delorean/engine.rb

@@ -54,11 +54,15 @@ module Delorean
       @imports[name] || err(ParseError, "#{name} not imported")
     end
 
-    # Check to see if node with given name is defined.  flag tell the
+    def is_node_defined(name)
+      @pm.constants.member? name.to_sym
+    end
+
+    # Check to see if node with given name is defined.  flag tells the
     # method about our expectation.  flag=true means that we make sure
     # that name is defined.  flag=false is the opposite.
     def parse_check_defined_node(name, flag)
-      isdef = @pm.constants.member? name.to_sym
+      isdef = is_node_defined(name)
 
       if isdef != flag
         isdef ? err(RedefinedError, "#{name} already defined") :
@@ -81,8 +85,7 @@ module Delorean
 
       sname = pname ? super_name(pname, mname) : 'Object'
 
-      code = "class #{name} < #{sname}; end"
-      @pm.module_eval(code)
+      @pm.module_eval("class #{name} < #{sname}; end")
 
       # latest defined node
       @last_node = name

data/lib/delorean/nodes.rb

@@ -118,15 +118,28 @@ eos
 
   class NodeAsValue < SNode
     def check(context, *)
+      node_name = c.text_value
       mname = mod.m.text_value if defined?(mod.m)
-      context.parse_check_defined_mod_node(c.text_value, mname)
+      begin
+        context.parse_check_defined_mod_node(node_name, mname)
+      rescue UndefinedError, ParseError
+        # Node is a non-Delorean ruby class
+        context.parse_class(text_value)
+      end
       []
     end
 
     def rewrite(context)
       node_name = c.text_value
       mname = mod.m.text_value if defined?(mod.m)
-      context.super_name(node_name, mname)
+      begin
+        context.parse_check_defined_mod_node(node_name, mname)
+        context.super_name(node_name, mname)
+      rescue UndefinedError, ParseError
+        # kind of hacky, we wrap the class name in a list so Call will
+        # be able to tell it apart from a regular value.
+        [text_value]
+      end
     end
   end
 
@@ -153,14 +166,24 @@ eos
     end
   end
 
+  # hacky, for backwards compatibility
+  class ErrorOp < SNode
+    def check(context, *)
+      args.check(context)
+    end
+
+    def rewrite(context, *)
+      "_err(#{args.rewrite(context)})"
+    end
+  end
+
   class IndexOp < SNode
     def check(context, *)
-      vc, ac = v.check(context), args.check(context)
-      ac + vc
+      args.check(context)
     end
 
-    def rewrite(context)
-      "_index(#{v.rewrite(context)}, [#{args.rewrite(context)}], _e)"
+    def rewrite(context, vcode)
+      "_index(#{vcode}, [#{args.rewrite(context)}], _e)"
     end
   end
 
@@ -175,7 +198,7 @@ eos
     end
   end
 
-  class String < Literal
+  class DString < Literal
     def rewrite(context)
       # remove the quotes and requote.  We don't want the likes of #{}
       # evals to just pass through.
@@ -199,33 +222,111 @@ eos
     end
   end
 
-  class ExpGetAttr < SNode
+  ######################################################################
+
+  class GetattrExp < SNode
     def check(context, *)
       v.check(context)
+      dotted.check(context)
     end
 
     def rewrite(context)
-      attr_list = ga.text_value.split('.')
+      vcode = v.rewrite(context)
+      dotted.rewrite(context, vcode)
+    end
+  end
 
-      # If ga.text_value is not "", then we need to drop the 1st
-      # element since it'll be "".
-      attr_list.shift
+  class Dotted < SNode
+    def check(context, *)
+      d.check(context)
+      d_rest.check(context) unless d_rest.text_value.empty?
+      []
+    end
 
-      attr_list.inject(v.rewrite(context)) {|x, y| "_get_attr(#{x}, '#{y}', _e)"}
+    def rewrite(context, vcode)
+      dcode = d.rewrite(context, vcode)
+
+      if d_rest.text_value.empty?
+        dcode
+      else
+        d_rest.rewrite(context, dcode)
+      end
+    end
+  end
+
+  class GetAttr < SNode
+    def check(context, *)
+      []
+    end
+
+    def rewrite(context, vcode)
+      "_get_attr(#{vcode}, '#{i.text_value}', _e)"
     end
   end
 
-  class Fn < SNode
+  class Call < SNode
     def check(context, *)
-      acount, res =
-        defined?(args) ? [args.arg_count, args.check(context)] : [0, []]
+      al.check(context) unless al.text_value.empty?
+      []
+    end
 
-      context.parse_check_call_fn(fn.text_value, acount)
-      res
+    def rewrite(context, vcode)
+      args, kw = al.text_value.empty? ? [[], {}] : al.rewrite(context)
+
+      raise "Keyword arguments not supported" unless
+        kw.empty?
+
+      args_str = args.reverse.join(',')
+
+      if vcode.is_a? Array
+        # ruby class call
+        class_name = vcode[0]
+        context.parse_check_call_fn(i.text_value, args.count, class_name)
+        "#{class_name}.#{i.text_value}(#{args_str})"
+      else
+        "_instance_call(#{vcode}, '#{i.text_value}', [#{args_str}])"
+      end
+
+    end
+  end
+
+  class NodeCall < SNode
+    def check(context, *)
+      al.check(context) unless al.text_value.empty?
+      []
+    end
+
+    def rewrite(context, node_name)
+      do_rewrite(context, node_name)
+    end
+
+    def do_rewrite(context, node_name, mname="nil")
+      args, kw = al.text_value.empty? ? [[], {}] : al.rewrite(context)
+
+      raise "No positional arguments to node call" unless
+        args.empty?
+
+      kw_str = '{' + kw.map {|k, v| "'#{k}' => #{v}" }.join(',') + '}'
+
+      "_node_call(#{node_name}, #{mname}, _e, #{kw_str})"
+    end
+  end
+
+  ######################################################################
+
+  class ExpGetAttr < SNode
+    def check(context, *)
+      v.check(context)
     end
 
     def rewrite(context)
-      fn.text_value + "(_e, " + (defined?(args) ? args.rewrite(context) : "") + ")"
+      attr_list = ga.text_value.split('.')
+
+      # If ga.text_value is not "", then we need to drop the 1st
+      # element since it'll be "".
+      attr_list.shift
+
+      attr_list.inject(v.rewrite(context)) {|x, y| "_get_attr(#{x}, '#{y}', _e)"}
     end
   end
 
@@ -247,21 +348,6 @@ eos
     end
   end
 
-  class ModelFn < SNode
-    def check(context, *)
-      acount, res =
-        defined?(args) ? [args.arg_count, args.check(context)] : [0, []]
-
-      context.parse_check_call_fn(fn.text_value, acount, m.text_value)
-      res
-    end
-
-    def rewrite(context)
-      m.text_value + "." + fn.text_value +
-        "(" + (defined?(args) ? args.rewrite(context) : "") + ")"
-    end
-  end
-
   class IfElse < SNode
     def check(context, *)
       vc, e1c, e2c =
@@ -397,45 +483,4 @@ eos
     end
   end
 
-  class ScriptCall < SNode
-    def check(context, *)
-      i.check(context) unless i.text_value.empty?
-      al.check(context) if defined?(al)
-      []
-    end
-
-    def rewrite(context)
-      node_name = i.text_value.empty? ? "nil" : i.rewrite(context)
-      do_rewrite(context, node_name)
-    end
-
-    def do_rewrite(context, node_name, mname="nil")
-      args, kw = al.rewrite(context)
-
-      args_str = '[' + args.reverse.join(',') + ']'
-      kw_str = '{' + kw.map {|k, v| "'#{k}' => #{v}" }.join(',') + '}'
-
-      "_script_call(#{node_name}, #{mname}, _e, #{args_str}, #{kw_str})"
-    end
-  end
-
-  class ScriptCallNode < ScriptCall
-    def check(context, *)
-      # FIXME: for both this and when node_name is nil, should check
-      # to see if attributes exist on the node before allowing the
-      # call.  Also, can check parameters.
-
-      mname = mod.m.text_value if defined?(mod.m)
-      context.parse_check_defined_mod_node(c.text_value, mname)
-
-      al.check(context) if defined?(al)
-      []
-    end
-
-    def rewrite(context)
-      node_name = c.text_value.inspect
-      mname = defined?(mod.m) ? mod.m.text_value.inspect : "nil"
-      do_rewrite(context, node_name, mname)
-    end
-  end
 end

data/lib/delorean/version.rb

@@ -1,3 +1,3 @@
 module Delorean
-  VERSION = "0.0.43"
+  VERSION = "0.1.00"
 end

data/lib/delorean_lang.rb

@@ -4,7 +4,6 @@ require 'treetop'
 require 'delorean/delorean'
 require 'delorean/nodes'
 require 'delorean/engine'
-require 'delorean/functions'
 require 'delorean/base'
 require 'delorean/error'
 require 'delorean/container'

data/spec/eval_spec.rb

@@ -440,7 +440,7 @@ eof
 
   it "should handle invalid expression evaluation" do
     # Should handle errors on expression such as -[] or -"xxx" or ("x"
-    # + []) better. Currently, it raised NoMethodError.
+    # + []) better. Currently, it raises NoMethodError.
     pending
   end
 
@@ -557,14 +557,25 @@ eof
     engine.evaluate("A", "c").should == {0.5=>50}
   end
 
+  it "should eval node calls as intermediate results" do
+    engine.parse defn("A:",
+                      "  a =?",
+                      "  e = A(a: 13)",
+                      "  d = e.a * 2",
+                      "  f = e.d / e.a",
+                      )
+
+    engine.evaluate_attrs("A", ["d", "f"]).should == [26, 2]
+  end
+
   it "should eval module calls 1" do
     engine.parse defn("A:",
                       "  a = 123",
                       "  n = A",
-                      "  d = @n('a')",
+                      "  d = n().a",
                       )
 
-    engine.evaluate_attrs("A", %w{d}).should == [{"a" => 123}]
+    engine.evaluate_attrs("A", %w{d}).should == [123]
   end
 
   it "should eval module calls 2" do
@@ -572,19 +583,30 @@ eof
                       "  a = 123",
                       "  b = 456 + a",
                       "  n = 'A'",
-                      "  c = @('a', 'b', x: 123, y: 456)",
-                      "  d = @n('a', 'b', x: 123, y: 456)",
-                      "  e = @('b')",
+                      "  c = nil(x: 123, y: 456) % ['a', 'b']",
+                      "  d = n(x: 123, y: 456) % ['a', 'b']",
+                      "  e = nil() % ['b']",
                       )
 
     engine.evaluate_attrs("A", %w{n c d e}).should ==
       ["A", {"a"=>123, "b"=>579}, {"a"=>123, "b"=>579}, {"b"=>579}]
   end
 
+  it "should eval module calls 3" do
+    engine.parse defn("A:",
+                      "  a = 123",
+                      "B:",
+                      "  n = 'A'",
+                      "  d = n().a",
+                      )
+
+    engine.evaluate_attrs("B", %w{d}).should == [123]
+  end
+
   it "should be possible to implement recursive calls" do
     engine.parse defn("A:",
                       "  n =?",
-                      "  fact = if n <= 1 then 1 else n * @('fact', n: n-1).fact",
+                      "  fact = if n <= 1 then 1 else n * A(n: n-1).fact",
                       )
     
     engine.evaluate("A", "fact", "n" => 10).should == 3628800
@@ -593,9 +615,9 @@ eof
   it "should eval module calls by node name" do
     engine.parse defn("A:",
                       "  a = 123",
-                      "  b = @A('a')",
+                      "  b = A().a",
                       )
-    engine.evaluate("A", "b").should == {"a"=>123}
+    engine.evaluate("A", "b").should == 123
   end
 
   it "should eval multiline expressions" do
@@ -614,16 +636,12 @@ eof
                       "  b = 456 + ",
                       "      a",
                       "  n = 'A'",
-                      "  c = @('a', ",
-                      "        'b', ",
-                      "        x: 123, ",
-                      "        y: 456)",
-                      "  d = @n('a', ",
-                      "         'b', ",
-                      "         x: 123, y: 456)",
-                      "  e = @(",
-                      "        'b'",
-                      "       )",
+                      "  c = nil(x: 123,",
+                      "        y: 456) % ['a', 'b']",
+                      "  d = n(",
+                      "         x: 123, y: 456) % ['a', 'b']",
+                      "  e = nil(",
+                      "       ) % ['b']",
                       )
 
     engine.evaluate_attrs("A", %w{n c d e}).should ==
@@ -636,10 +654,10 @@ eof
                       "  b = 456",
                       "B: AAA::X",
                       "  a = 111",
-                      "  c = @AAA::X('b', a: 456)",
+                      "  c = AAA::X(a: 456).b",
                       ), sset
     engine.evaluate_attrs("B", ["a", "b", "c"], {}).should ==
-      [111, 222, {"b"=>456*2}]
+      [111, 222, 456*2]
   end
 
   it "should eval imports (2)" do
@@ -648,7 +666,7 @@ eof
                  defn("import AAA 0001",
                       "B: AAA::X",
                       "  a = 111",
-                      "  c = @AAA::X('b', a: -1)",
+                      "  c = AAA::X(a: -1).b",
                       "  d = a * 2",
                       ),
                  ["CCC", "0003"] =>
@@ -664,7 +682,7 @@ eof
     e2 = sset.get_engine("BBB", "0002")
 
     e2.evaluate_attrs("B", ["a", "b", "c", "d"]).should ==
-      [111, 222, {"b"=>-2}, 222]
+      [111, 222, -2, 222]
 
     engine.parse defn("import BBB 0002",
                       "B: BBB::B",
@@ -672,12 +690,12 @@ eof
                       ), sset
 
     engine.evaluate_attrs("B", ["a", "b", "c", "d", "e"]).should ==
-      [111, 222, {"b"=>-2}, 222, 225]
+      [111, 222, -2, 222, 225]
 
     e4 = sset.get_engine("CCC", "0003")
 
     e4.evaluate_attrs("B", ["a", "b", "c", "d", "e"]).should ==
-      [111, 222, {"b"=>-2}, 222, 666]
+      [111, 222, -2, 222, 666]
 
     e4.evaluate_attrs("C", ["a", "b", "d"]).should == [123, 123*2, 123*3*2]
   end
@@ -688,7 +706,7 @@ eof
                  ["CCC", "0003"] =>
                  defn("import BBB 0002",
                       "X:",
-                      "  xx = [n.x for n in @BBB::D('xs').xs]",
+                      "  xx = [n.x for n in BBB::D().xs]",
                       "  yy = [n.x for n in BBB::D.xs]",
                       ),
                })
@@ -710,4 +728,14 @@ eof
     r.should == [2, 3, 456]
   end
 
+  it "can eval indexing 2" do
+    engine.parse defn("A:",
+                      "  a = 1",
+                      "  b = {'x' : 123, 'y': 456}",
+                      "  c = A() % ['a', 'b']",
+                      "  d = c['b'].x * c['a'] - c['b'].y",
+                      )
+    r = engine.evaluate_attrs("A", ["a", "b", "c", "d"])
+    r.should == [1, {"x"=>123, "y"=>456}, {"a"=>1, "b"=>{"x"=>123, "y"=>456}}, -333]
+  end
 end