delorean_lang 0.0.43 → 0.1.00

data/spec/func_spec.rb

@@ -8,60 +8,27 @@ describe "Delorean" do
 
   it "should handle MAX as a node name" do
     engine.parse defn("MAX:",
-                      "  a = MAX(1, 2, 3, 0, -10)",
+                      "  a = [1, 2, 3, 0, -10].max()",
                       )
 
     r = engine.evaluate("MAX", "a")
     r.should == 3
   end
 
-  it "should handle MAX" do
-    engine.parse defn("A:",
-                      "  a = MAX(1, 2, 3)",
-                      )
-
-    r = engine.evaluate("A", "a")
-    r.should == 3
-  end
-
-  it "should handle insufficient args" do
-    lambda {
-      engine.parse defn("A:",
-                        "  a = MAX(1)",
-                        )
-    }.should raise_error(Delorean::BadCallError)
-  end
-
   it "should handle MIN" do
     engine.parse defn("A:",
-                      "  a = MIN(1, 2, -3, 4)",
+                      "  a = [1, 2, -3, 4].min()",
                       )
 
     r = engine.evaluate("A", "a")
     r.should == -3
   end
 
-  it "should handle MAXLIST" do
-    engine.parse defn("A:",
-                      "  a = MAXLIST([1, 2, 3])",
-                      )
-
-    engine.evaluate("A", "a").should == 3
-  end
-
-  it "should handle MINLIST" do
-    engine.parse defn("A:",
-                      "  a = MINLIST([1, 10, -3])",
-                      )
-
-    engine.evaluate("A", "a").should == -3
-  end
-
   it "should handle ROUND" do
     engine.parse defn("A:",
-                      "  a = ROUND(12.3456, 2)",
-                      "  b = ROUND(12.3456, 1)",
-                      "  c = ROUND(12.3456)",
+                      "  a = 12.3456.round(2)",
+                      "  b = 12.3456.round(1)",
+                      "  c = 12.3456.round()",
                       )
 
     r = engine.evaluate_attrs("A", ["a", "b", "c"])
@@ -70,9 +37,9 @@ describe "Delorean" do
 
   it "should handle NUMBER" do
     engine.parse defn("A:",
-                      "  a = NUMBER(12.3456)",
-                      "  b = NUMBER('12.3456')",
-                      "  c = NUMBER('12')",
+                      "  a = 12.3456.to_f()",
+                      "  b = '12.3456'.to_f()",
+                      "  c = '12'.to_f()",
                       )
 
     r = engine.evaluate_attrs("A", ["a", "b", "c"])
@@ -81,10 +48,10 @@ describe "Delorean" do
 
   it "should handle ABS" do
     engine.parse defn("A:",
-                      "  a = ABS(-123)",
-                      "  b = ABS(-1.1)",
-                      "  c = ABS(2.3)",
-                      "  d = ABS(0)",
+                      "  a = (-123).abs()",
+                      "  b = (-1.1).abs()",
+                      "  c = 2.3.abs()",
+                      "  d = 0.abs()",
                       )
 
     r = engine.evaluate_attrs("A", ["a", "b", "c", "d"])
@@ -93,9 +60,9 @@ describe "Delorean" do
 
   it "should handle STRING" do
     engine.parse defn("A:",
-                      "  a = STRING('hello')",
-                      "  b = STRING(12.3456)",
-                      "  c = STRING([1,2,3])",
+                      "  a = 'hello'.to_s()",
+                      "  b = 12.3456.to_s()",
+                      "  c = [1,2,3].to_s()",
                       )
 
     r = engine.evaluate_attrs("A", ["a", "b", "c"])
@@ -105,21 +72,16 @@ describe "Delorean" do
   it "should handle TIMEPART" do
     engine.parse defn("A:",
                       "  p =?",
-                      "  p2 =?",
-                      "  h = TIMEPART(p, 'h')",
-                      "  m = TIMEPART(p, 'm')",
-                      "  s = TIMEPART(p, 's')",
-                      "  d = TIMEPART(p, 'd')",
-                      "  d2 = TIMEPART(p2, 'd')",
-                      "  h2 = TIMEPART(p2, 'h')",
+                      "  h = p.hour()",
+                      "  m = p.min()",
+                      "  s = p.sec()",
+                      "  d = p.to_date()",
                       )
 
     p = Time.now
-    params = {"p" => p, "p2" => Float::INFINITY}
-    r = engine.evaluate_attrs("A", %w{h m s d d2}, params)
-    r.should == [p.hour, p.min, p.sec, p.to_date, Float::INFINITY]
-
-    expect { engine.evaluate_attrs("A", ["h2"], params) }.to raise_error
+    params = {"p" => p}
+    r = engine.evaluate_attrs("A", %w{h m s d}, params)
+    r.should == [p.hour, p.min, p.sec, p.to_date]
 
     # Non time argument should raise an error
     expect { engine.evaluate_attrs("A", ["m"], {"p" => 123}) }.to raise_error
@@ -129,9 +91,9 @@ describe "Delorean" do
   it "should handle DATEPART" do
     engine.parse defn("A:",
                       "  p =?",
-                      "  y = DATEPART(p, 'y')",
-                      "  d = DATEPART(p, 'd')",
-                      "  m = DATEPART(p, 'm')",
+                      "  y = p.year()",
+                      "  d = p.day()",
+                      "  m = p.month()",
                       )
 
     p = Date.today
@@ -140,45 +102,6 @@ describe "Delorean" do
 
     # Non date argument should raise an error
     expect { engine.evaluate_attrs("A", ["y", "d", "m"], {"p" => 123}) }.to raise_error
-     # Invalid part argument should raise an error
-    engine.reset
-    engine.parse defn("A:",
-                      "  p =?",
-                      "  x = DATEPART(p, 'x')",
-                      )
-    expect { engine.evaluate_attrs("A", ["x"], {"p" => p}) }.to raise_error
-  end
-
-  it "should handle DATEADD" do
-    engine.parse defn("A:",
-                      "  p =?",
-                      "  y = DATEADD(p, 1, 'y')",
-                      "  d = DATEADD(p, 30, 'd')",
-                      "  m = DATEADD(p, 2, 'm')",
-                      )
-
-    p = Date.today
-    r = engine.evaluate_attrs("A", ["y", "d", "m"], {"p" => p})
-    r.should == [p + 1.years, p + 30.days, p + 2.months]
-
-    # Non date argument should raise an error
-    expect { engine.evaluate_attrs("A", ["y", "d", "m"], {"p" => 123}) }.to raise_error
-
-    # Invalid interval argument should raise an error
-    engine.reset
-    engine.parse defn("A:",
-                      "  p =?",
-                      "  m = DATEADD(p, 1.3, 'm')",
-                      )
-    expect { engine.evaluate_attrs("A", ["m"], {"p" => p}) }.to raise_error
-   
-    # Invalid part argument should raise an error
-    engine.reset
-    engine.parse defn("A:",
-                      "  p =?",
-                      "  x = DATEADD(p, 1, 'x')",
-                      )
-    expect { engine.evaluate_attrs("A", ["x"], {"p" => p}) }.to raise_error
   end
 
   it "should handle FLATTEN" do
@@ -186,7 +109,7 @@ describe "Delorean" do
 
     engine.parse defn("A:",
                       "  a = #{x}",
-                      "  b = FLATTEN(a) + FLATTEN(a, 1)"
+                      "  b = a.flatten() + a.flatten(1)"
                       )
 
     engine.evaluate("A", "b").should == x.flatten + x.flatten(1)
@@ -210,14 +133,16 @@ describe "Delorean" do
 
     engine.parse defn("A:",
                       "  a = #{x}",
-                      "  b = RUBY('flatten', a)",
-                      "  c = RUBY('flatten', a, 1)",
+                      "  b = a.flatten()",
+                      "  c = a.flatten(1)",
                       "  d = b+c",
-                      "  dd = RUBY('flatten', d)",
-                      "  e = RUBY('sort', dd)",
-                      "  f = RUBY('uniq', e)",
-                      "  g = RUBY('length', e)",
-                      "  gg = RUBY('length', a)",
+                      "  dd = d.flatten()",
+                      "  e = dd.sort()",
+                      "  f = e.uniq()",
+                      "  g = e.length()",
+                      "  gg = a.length()",
+                      "  l = a.member(5)",
+                      "  m = [a.member(5), a.member(55)]",
                       )
 
     engine.evaluate("A", "c").should == x.flatten(1)
@@ -227,6 +152,7 @@ describe "Delorean" do
     engine.evaluate("A", "f").should == dd.sort.uniq
     engine.evaluate("A", "g").should == dd.length
     engine.evaluate("A", "gg").should == x.length
+    engine.evaluate("A", "m").should == [x.member?(5), x.member?(55)]
   end
 
   it "should handle RUBY slice function" do
@@ -234,7 +160,7 @@ describe "Delorean" do
 
     engine.parse defn("A:",
                       "  a = #{x}",
-                      "  b = RUBY('slice',a,0,4)",
+                      "  b = a.slice(0, 4)",
                       )
     engine.evaluate("A", "b").should == x.slice(0,4)
   end

data/spec/parse_spec.rb

@@ -50,6 +50,13 @@ describe "Delorean" do
                       )
   end
 
+  it "can parse indexing with getattr" do
+    engine.parse defn("A:",
+                      "  a = {'x': [1,2,3]}",
+                      "  b = a.x[1]",
+                      )
+  end
+
   it "should accept default param definitions" do
     lambda {
       engine.parse defn("A:",
@@ -290,6 +297,15 @@ describe "Delorean" do
     }.should_not raise_error
   end
 
+  it "should parse calls followed by getattr" do
+    lambda {
+      engine.parse defn("A:",
+                        "  a = -1",
+                        "  b = A().a",
+                        )
+    }.should_not raise_error
+  end
+
   it "should be able to chain method calls on model functions" do
     lambda {
       engine.parse defn("A:",
@@ -304,6 +320,14 @@ describe "Delorean" do
                       )
   end
 
+  it "should get exception on arg count to class method call" do
+    lambda {
+      engine.parse defn("A:",
+                        '  b = Dummy.i_just_met_you("CRJ")',
+                        )
+    }.should raise_error(Delorean::BadCallError)
+  end
+
   it "shouldn't be able to call ActiveRecord methods without signature" do
     lambda {
       engine.parse defn("A:",
@@ -328,10 +352,6 @@ describe "Delorean" do
                       )
   end
 
-  it "should raise error on node attr access without all needed params" do
-    pending
-  end
-
   it "should be able to access derived attrs" do
     engine.parse defn("A:",
                       "  b =? 22",
@@ -614,15 +634,21 @@ describe "Delorean" do
                       "  a = 123",
                       "  b = 456 + a",
                       "  n = 'A'",
-                      "  c = @('a', 'b', x: 123, y: 456)",
-                      "  d = @n('a', 'b', x: 123, y: 456)",
+                      "  c = nil(x: 123, y: 456)",
+                      "  d = n(x: 123, y: 456)",
                       )
   end
 
   it "should parse module calls by node name" do
     engine.parse defn("A:",
                       "  a = 123",
-                      "  d = @A('a')",
+                      "  d = A()",
+                      )
+  end
+
+  it "should parse instance calls" do
+    engine.parse defn("A:",
+                      "  a = [1,2,[4]].flatten(1)",
                       )
   end
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: delorean_lang
 version: !ruby/object:Gem::Version
-  version: 0.0.43
+  version: 0.1.00
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-06-11 00:00:00.000000000 Z
+date: 2013-06-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: treetop
@@ -96,7 +96,6 @@ files:
 - lib/delorean/delorean.treetop
 - lib/delorean/engine.rb
 - lib/delorean/error.rb
-- lib/delorean/functions.rb
 - lib/delorean/model.rb
 - lib/delorean/nodes.rb
 - lib/delorean/version.rb

data/lib/delorean/functions.rb

@@ -1,200 +0,0 @@
-module Delorean
-  module Functions
-
-    ######################################################################
-
-    def MAX(_e, *args)
-      args.max
-    end
-
-    MAX_SIG = [ 2, Float::INFINITY ]
-
-    ######################################################################
-
-    def MIN(_e, *args)
-      args.min
-    end
-
-    MIN_SIG = MAX_SIG
-
-    ######################################################################
-
-    def MAXLIST(_e, arg)
-      raise "argument must be list" unless arg.is_a? Array
-      arg.max
-    end
-
-    MAXLIST_SIG = [ 1, 1 ]
-
-    ######################################################################
-
-    def MINLIST(_e, arg)
-      raise "argument must be list" unless arg.is_a? Array
-      arg.min
-    end
-
-    MINLIST_SIG = [ 1, 1 ]
-
-    ######################################################################
-
-    def ROUND(_e, number, *args)
-      number.round(*args)
-    end
-
-    ROUND_SIG = [ 1, 2 ]
-
-    ######################################################################
-
-    def ABS(_e, n)
-      raise "#{n} is not a number" unless
-        n.is_a?(Float) || n.is_a?(Fixnum) || n.is_a?(BigDecimal)
-      n.abs
-    end
-
-    ABS_SIG = [ 1, 1 ]
-
-    ######################################################################
-
-    def NUMBER(_e, s)
-      # FIXME: handle BigDecimal
-      return s if s.is_a?(Float) || s.is_a?(Fixnum) || s.is_a?(BigDecimal)
-      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"
-      end
-
-      raise "non-time arg to TIMEPART" unless
-        time.is_a?(DateTime) || time.is_a?(Time)
-      
-      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(_e, date, part)
-      raise "non-date arg to DATEPART" unless date.is_a?(Date)
-
-      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(_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)
-
-      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 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))
-      array.flatten(*args)
-    end
-
-    FLATTEN_SIG = [ 1, 2 ]
-
-    ######################################################################
-
-    def ERR(_e, *args)
-      str = args.map(&:to_s).join(", ")
-      raise str
-    end
-
-    ERR_SIG = [ 1, Float::INFINITY ]
-
-    ######################################################################
-
-    RUBY_METHODS = {
-      sort: 	[Array],
-      reverse: 	[Array],
-      min: 	[Array],
-      max: 	[Array],
-      uniq: 	[Array],
-      length: 	[[Array, String]],
-      flatten:	[Array, [Fixnum, nil]],
-      slice:    [Array, Fixnum, Fixnum],
-      member?:	[Array, [Fixnum, String]],
-      compact:	[Array],
-      split:	[String, String],
-    }
-
-    def RUBY(_e, method, *args)
-      raise "method must be a string" unless method.class.name=="String"
-      msg = method.to_sym
-
-      raise "no such method #{method}" unless RUBY_METHODS.member? msg
-
-      sig = RUBY_METHODS[msg]
-      raise "too many args to #{method}" if args.length>sig.length
-
-      sig.each_with_index { |s, i|
-        s = [s] unless s.is_a?(Array)
-
-        ok = false
-        s.each { |sc|
-          if (sc.nil? && i>=args.length) || (sc && args[i].class <= sc)
-            ok = true
-            break
-          end
-        }
-
-        raise "bad arg #{i} to method #{method}: #{args[i]}/#{args[i].class}" unless ok
-      }
-
-      args[0].send(msg, *args[1, args.length])
-    end
-   
-    RUBY_SIG = [ 1, Float::INFINITY ]
-
-    ######################################################################
-
-  end
-end