delorean_lang 2.1.0 → 2.3.0

data/lib/delorean/delorean.treetop

@@ -32,6 +32,10 @@ grammar Delorean
     [A-Z] [a-zA-Z0-9_]* (('::' [A-Z] [a-zA-Z0-9_]*) 2..)
   end
 
+  rule elsif
+    'elsif' sp? v:expression sp? 'then' sp? e1:expression sp?
+  end
+
   rule expression
     'ERR(' sp? args:fn_args? sp? ')' <ErrorOp>
     /
@@ -41,6 +45,11 @@ grammar Delorean
     'then'      sp? e1:expression sp?
     'else'      sp? e2:expression <IfElse>
     /
+    'if'        sp? v:expression sp?
+    'then'      sp? e1:expression sp?
+    sp? elsifs:elsif+ sp?
+    'else'      sp? e2:expression <IfElsifElse>
+    /
     v:getattr_exp sp? op:binary_op sp? e:expression <BinOp>
     /
     getattr_exp
@@ -138,8 +147,8 @@ grammar Delorean
     string                                              /
     boolean                                             /
     nil_val                                             /
-    identifier                                          /
     sup                                                 /
+    identifier                                          /
     self                                                /
     list_expr                                           /
     set_expr                                            /
@@ -186,7 +195,8 @@ grammar Delorean
   end
 
   rule identifier
-    [a-z] [a-zA-Z0-9_]* '?'? <Identifier>
+    [a-z] [a-zA-Z0-9_]* '?'? <Identifier> /
+    [_] [a-zA-Z0-9_]+ '?'? <Identifier> 
   end
 
   rule boolean

data/lib/delorean/engine.rb

@@ -258,7 +258,7 @@ module Delorean
         @line_no += 1
 
         # skip comments
-        next if line =~ /^\s*\#/
+        next if /^\s*\#/.match?(line)
 
         # remove trailing blanks
         line.rstrip!
@@ -302,7 +302,7 @@ module Delorean
         t = parser.parse(line)
 
         if !t
-          err(ParseError, 'syntax error') unless line =~ /^\s+/
+          err(ParseError, 'syntax error') unless /^\s+/.match?(line)
 
           multi_line = line
           @multi_no = @line_no
@@ -375,7 +375,7 @@ module Delorean
       if node.is_a?(Class)
         klass = node
       else
-        raise "bad node '#{node}'" unless node =~ /^[A-Z][a-zA-Z0-9_]*$/
+        raise "bad node '#{node}'" unless /^[A-Z][a-zA-Z0-9_]*$/.match?(node)
 
         begin
           klass = @m.const_get(node)
@@ -386,19 +386,58 @@ module Delorean
 
       params[:_engine] = self
 
+      if klass.respond_to?(NODE_CACHE_ARG) && klass.send(NODE_CACHE_ARG, params)
+        return _evaluate_with_cache(klass, attrs, params)
+      end
+
       if attrs.is_a?(Array)
         attrs.map do |attr|
-          raise "bad attribute '#{attr}'" unless attr =~ /^[a-z][A-Za-z0-9_]*$/
+          unless /^[_a-z][A-Za-z0-9_]*$/.match?(attr)
+            raise "bad attribute '#{attr}'"
+          end
 
           klass.send("#{attr}#{POST}".to_sym, params)
         end
       else
-        raise "bad attribute '#{attrs}'" unless attrs =~ /^[a-z][A-Za-z0-9_]*$/
+        unless /^[_a-z][A-Za-z0-9_]*$/.match?(attrs)
+          raise "bad attribute '#{attrs}'"
+        end
 
         klass.send("#{attrs}#{POST}".to_sym, params)
       end
     end
 
+    def _evaluate_with_cache(klass, attrs, params)
+      if attrs.is_a?(Array)
+        attrs.map do |attr|
+          unless /^[_a-z][A-Za-z0-9_]*$/.match?(attr)
+            raise "bad attribute '#{attr}'"
+          end
+
+          _evaluate_attr_with_cache(klass, attr, params)
+        end
+      else
+        unless /^[_a-z][A-Za-z0-9_]*$/.match?(attrs)
+          raise "bad attribute '#{attrs}'"
+        end
+
+        _evaluate_attr_with_cache(klass, attrs, params)
+      end
+    end
+
+    def _evaluate_attr_with_cache(klass, attr, params)
+      params_without_engine = params.reject { |k, _| k == :_engine }
+
+      ::Delorean::Cache.with_cache(
+        klass: klass,
+        method: attr,
+        mutable_params: params,
+        params: params_without_engine
+      ) do
+        klass.send("#{attr}#{POST}".to_sym, params)
+      end
+    end
+
     def eval_to_hash(node, attrs, params = {})
       res = evaluate(node, attrs, params)
       Hash[* attrs.zip(res).flatten(1)]

data/lib/delorean/nodes.rb

@@ -318,7 +318,9 @@ eos
   class IString < Literal
     def rewrite(_context)
       # FIXME: hacky to just fail
-      raise 'String interpolation not supported' if text_value =~ /\#\{.*\}/
+      if /\#\{.*\}/.match?(text_value)
+        raise 'String interpolation not supported'
+      end
 
       # FIXME: syntax check?
       text_value
@@ -388,7 +390,7 @@ eos
 
     def rewrite(_context, vcode)
       attr = i.text_value
-      attr = "'#{attr}'" unless attr =~ /\A[0-9]+\z/
+      attr = "'#{attr}'" unless /\A[0-9]+\z/.match?(attr)
       "_get_attr(#{vcode}, #{attr}, _e)"
     end
   end
@@ -626,6 +628,34 @@ eos
     end
   end
 
+  class IfElsifElse < SNode
+    def check(context, *)
+      vc = v.check(context)
+      e1c = e1.check(context)
+      e2c = e2.check(context)
+
+      elsifs_check = elsifs.elements.map do |node|
+        [node.v.check(context), node.e1.check(context)]
+      end.flatten
+
+      vc + e1c + e2c + elsifs_check
+    end
+
+    def rewrite(context)
+      elsifs_string = elsifs.elements.map do |node|
+        "elsif (#{node.v.rewrite(context)})
+           (#{node.e1.rewrite(context)})"
+      end.join("\n")
+
+      "if (#{v.rewrite(context)})
+         (#{e1.rewrite(context)})
+       #{elsifs_string}
+       else
+         (#{e2.rewrite(context)})
+      end"
+    end
+  end
+
   class ListExpr < SNode
     def check(context, *)
       defined?(args) ? args.check(context) : []

data/lib/delorean/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Delorean
-  VERSION = '2.1.0'
+  VERSION = '2.3.0'
 end

data/spec/eval_spec.rb

@@ -211,6 +211,46 @@ describe 'Delorean' do
     expect(engine.evaluate('A', 'c')).to eq([[1, 2, 3], ['a', 'b']])
   end
 
+  it 'should handle if else' do
+    engine.parse defn('A:',
+                      '    n =?',
+                      '    fact = if n <= 1 then 1',
+                      '            else n'
+                     )
+
+    expect(engine.evaluate('A', 'fact', 'n' => 0)).to eq(1)
+    expect(engine.evaluate('A', 'fact', 'n' => 10)).to eq(10)
+  end
+
+  it 'should handle elsif 1' do
+    engine.parse defn('A:',
+                      '    n =?',
+                      '    fact = if n <= 1 then 1',
+                      '            elsif n < 7 then 7',
+                      '            else n'
+                     )
+
+    expect(engine.evaluate('A', 'fact', 'n' => 0)).to eq(1)
+    expect(engine.evaluate('A', 'fact', 'n' => 5)).to eq(7)
+    expect(engine.evaluate('A', 'fact', 'n' => 10)).to eq(10)
+  end
+
+  it 'should handle elsif 2' do
+    engine.parse defn('A:',
+                      '    n =?',
+                      '    m = 2',
+                      '    fact = if n <= 1 then 1',
+                      '            elsif n < 3 then 3',
+                      '            elsif (n < 7 && (m + Dummy.call_me_maybe(n)) > 1) then 7',
+                      '            else n'
+                     )
+
+    expect(engine.evaluate('A', 'fact', 'n' => 0)).to eq(1)
+    expect(engine.evaluate('A', 'fact', 'n' => 2)).to eq(3)
+    expect(engine.evaluate('A', 'fact', 'n' => 5)).to eq(7)
+    expect(engine.evaluate('A', 'fact', 'n' => 10)).to eq(10)
+  end
+
   it 'should handle operator precedence properly' do
     engine.parse defn('A:',
                       '    b = 3+2*4-1',

data/spec/node_level_cache_spec.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe 'Node level caching' do
+  let(:sset) do
+    TestContainer.new(
+      'AAA' =>
+      defn('X:',
+           '    a =? 123',
+           '    b = a*2',
+          )
+    )
+  end
+
+  let(:engine) do
+    eng = Delorean::Engine.new 'XXX', sset
+
+    eng.parse defn('A:',
+                   '    _cache = true',
+                   '    arg1 =?',
+                   '    arg2 =?',
+                   '    arg3 =?',
+                   '    result = Dummy.all_of_me()',
+                   'B:',
+                   '    arg1 =?',
+                   '    arg2 =?',
+                   '    arg3 =?',
+                   '    result = A(arg1=arg1, arg2=arg2, arg3=arg3).result',
+                  )
+    eng
+  end
+
+  after do
+    default_callback = ::Delorean::Cache::NODE_CACHE_DEFAULT_CALLBACK
+
+    ::Delorean::Cache.node_cache_callback = default_callback
+    ::Delorean::Cache.adapter.clear_all!
+  end
+
+  def evaluate_b
+    r = engine.evaluate('B', 'result', 'arg1' => 1, 'arg2' => 2, 'arg3' => 3)
+    expect(r).to eq([{ 'name' => 'hello', 'foo' => 'bar' }])
+  end
+
+  def evaluate_a
+    r = engine.evaluate('A', 'result', 'arg1' => 1, 'arg2' => 2, 'arg3' => 3)
+    expect(r).to eq([{ 'name' => 'hello', 'foo' => 'bar' }])
+  end
+
+  it 'uses cache when the same arguments were passed' do
+    expect(Dummy).to receive(:all_of_me).once.and_call_original
+    2.times { evaluate_b }
+  end
+
+  it 'uses cache if evaluate is called from ruby' do
+    expect(Dummy).to receive(:all_of_me).once.and_call_original
+    2.times { evaluate_a }
+  end
+
+  it "doesn't use cache when the different arguments were passed" do
+    expect(Dummy).to receive(:all_of_me).twice.and_call_original
+
+    evaluate_a
+
+    r = engine.evaluate('A', 'result', 'arg1' => 10, 'arg2' => 2, 'arg3' => 3)
+    expect(r).to eq([{ 'name' => 'hello', 'foo' => 'bar' }])
+  end
+
+  describe 'compex caching' do
+    let(:engine) do
+      eng = Delorean::Engine.new 'XXX', sset
+
+      eng.parse defn('A:',
+                     '    _cache = true',
+                     '    arg1 =?',
+                     '    arg2 =?',
+                     '    arg3 =?',
+                     '    result = Dummy.all_of_me()',
+                     'B:',
+                     '    _cache = true',
+                     '    arg1 =?',
+                     '    arg2 =?',
+                     '    arg3 =?',
+                     '    result = [A(arg1=1, arg2=2, arg3=3).result, Dummy.one_or_two(1, 2)]',
+                     'C:',
+                     '    arg1 =?',
+                     '    result = [ Dummy.call_me_maybe(2), B(arg1=arg1, arg2=2, arg3=3).result]',
+                    )
+      eng
+    end
+
+    it 'Calling node can be cached as well' do
+      # A should be called once
+      expect(Dummy).to receive(:all_of_me).once.and_call_original
+
+      # B should be called twice
+      expect(Dummy).to receive(:one_or_two).twice.and_call_original
+
+      # C should be called 3 times
+      expect(Dummy).to receive(:call_me_maybe).exactly(3).times
+                                              .and_call_original
+
+      2.times do
+        r = engine.evaluate('C', 'result', 'arg1' => 1)
+        expect(r).to eq([2, [[{ 'name' => 'hello', 'foo' => 'bar' }], [1, 2]]])
+      end
+
+      r = engine.evaluate('C', 'result', 'arg1' => 2)
+      expect(r).to eq([2, [[{ 'name' => 'hello', 'foo' => 'bar' }], [1, 2]]])
+    end
+  end
+
+  it 'allows to override caching callback 1' do
+    ::Delorean::Cache.node_cache_callback = lambda do |**_kwargs|
+      {
+        cache: false,
+      }
+    end
+
+    expect(Dummy).to receive(:all_of_me).twice.and_call_original
+    2.times { evaluate_a }
+  end
+
+  it 'allows to override caching callback 2' do
+    ::Delorean::Cache.node_cache_callback = lambda do |**_kwargs|
+      {
+        cache: true,
+      }
+    end
+
+    expect(Dummy).to receive(:all_of_me).once.and_call_original
+    2.times { evaluate_a }
+  end
+end

data/spec/parse_spec.rb

@@ -112,7 +112,7 @@ describe 'Delorean' do
 
     expect do
       engine.parse defn('A:',
-                        '    _b = 1',
+                        '    %b = 1',
                        )
     end.to raise_error(Delorean::ParseError)
   end
@@ -167,6 +167,25 @@ describe 'Delorean' do
                      )
   end
 
+  it 'should allow elsif 1' do
+    engine.parse defn('A:',
+                      '    n =?',
+                      '    fact = if n <= 1 then 1',
+                      '            elsif n < 3 then 3',
+                      '            else n'
+                     )
+  end
+
+  it 'should allow elsif 2' do
+    engine.parse defn('A:',
+                      '    n =?',
+                      '    fact = if n <= 1 then 1',
+                      '            elsif n < 3 then 3',
+                      '            elsif n < 7 then Dummy.call_me_maybe(7)',
+                      '            else n'
+                     )
+  end
+
   it 'should allow non-recursive code 1' do
     # this is not a recursion error
     engine.parse defn('A:',

data/spec/perf_spec.rb

@@ -152,6 +152,48 @@ describe 'Delorean' do
     expect(factor).to be < 8
   end
 
+  it 'cache allows to get result faster' do
+    perf_test = <<-DELOREAN
+    A:
+        v =?
+        result = Dummy.sleep_1ms
+
+    AWithCache:
+        _cache = true
+        v =?
+        result = Dummy.sleep_1ms
+    DELOREAN
+
+    engine.parse perf_test.gsub(/^    /, '')
+
+    bm = Benchmark.ips do |x|
+      x.report('delorean') do
+        engine.evaluate('A', 'result', {})
+      end
+
+      x.report('delorean_node_cache') do
+        engine.evaluate('AWithCache', 'result', {})
+      end
+
+      x.report('ruby') do
+        Dummy.sleep_1ms
+      end
+
+      x.compare!
+    end
+
+    # get iterations/sec for each report
+    h = bm.entries.each_with_object({}) do |e, hh|
+      hh[e.label] = e.stats.central_tendency
+    end
+
+    cache_factor = h['delorean_node_cache'] / h['delorean']
+    # p cache_factor
+
+    expected_cache_factor = ENV['COVERAGE'] ? 64 : 80
+    expect(cache_factor).to be > expected_cache_factor
+  end
+
   it 'array and node call performance as expected' do
     perf_test = <<-DELOREAN
     A: