delorean_lang 0.4.7 → 0.4.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f606ebe7eea8de6ef41dcc2de653b09ed4177308
-  data.tar.gz: b545ce6a844aa31945cd590f73a456a23c68e613
+  metadata.gz: 3a6eb15c510767db6fe200846f73c99332074552
+  data.tar.gz: a088e3928a4646f276f23f144e05fb1ed5d2717b
 SHA512:
-  metadata.gz: d934f9c0172103dc572132b42ca728749801d50a3f63e87574d4788c09c995f4a475aaa9c96ebfc6f430732190fc2dd059e285587a9b53f1a406bb65d09289d0
-  data.tar.gz: 87ce61ccb1bce7c5e89df4bb8d0b975adcc4297cfaa8b913c5f318a02cee2d9b658479b446e81c13b73490d26a7d1429387a9d0053cefd26f0beb3e6df19d974
+  metadata.gz: 542634f338cb3af160f4a333548cbb65bd98337d6ea5cce30176c27dd7c574bdb4ce84bb0e5e5f0a4160e55a5ba01fa52533e4b41c4cb87d6bcec5d7949413d9
+  data.tar.gz: 6f13545b0fe049fd9d8ee461eab5047c8f1b0d446207751f0c10f3a10dcdcc89778f18045953e4394bce159a23122470de269b80682fea0fa50814f31d6f6478

data/README.md

@@ -135,6 +135,33 @@ TODO: provide details on the following topics:
 This implementation of Delorean "compiles" script code to
 Ruby.
 
+### Calling ruby methods from Delorean
+
+Ruby methods that are called from Delorean should be whitelisted.
+
+```ruby
+
+  ::Delorean::Ruby.whitelist.add_method :length do |method|
+    method.called_on String
+    method.called_on Enumerable
+  end
+
+  ::Delorean::Ruby.whitelist.add_method :first do |method|
+    method.called_on Enumerable, with: [Integer]
+  end
+
+```
+
+By default Delorean has some methods whitelisted, such as `length`, `min`, `max`, etc. Those can be found in `/lib/delorean/ruby/whitelists/default`. If you don't want to use defaults, you can override whitelist with and empty one.
+
+```ruby
+
+  require 'delorean/ruby/whitelists/empty'
+
+  ::Delorean::Ruby.whitelist = ::Delorean::Ruby::Whitelists::Empty.new
+
+```
+
 ### Caching
 
 Delorean provides `cached_delorean_function` method that will cache result based on arguments.

data/lib/delorean/abstract_container.rb

@@ -0,0 +1,9 @@
+require 'delorean/base'
+
+module Delorean
+  class AbstractContainer
+    def get_engine(name)
+      raise "get_engine needs to be overriden"
+    end
+  end
+end

data/lib/delorean/base.rb

@@ -1,92 +1,15 @@
 require 'active_support/time'
 require 'active_record'
 require 'bigdecimal'
+require 'delorean/ruby'
+require 'delorean/ruby/whitelists/default'
 require 'delorean/cache'
 
 module Delorean
 
-  ::Delorean::Cache.adapter = ::Delorean::Cache::Adapters::RubyCache.new(size_per_class: 1000)
+  ::Delorean::Ruby.whitelist = ::Delorean::Ruby::Whitelists::Default.new
 
-  TI_TYPES   = [Time, ActiveSupport::TimeWithZone]
-  DT_TYPES   = [Date] + TI_TYPES
-  NUM_OR_STR = [Numeric, String]
-  NUM_OR_NIL = [nil, Integer]
-
-  # FIXME: the whitelist is quite hacky.  It's currently difficult to
-  # override it.  A user will likely want to directly modify this
-  # hash.  The whole whitelist mechanism should be eventually
-  # rethought.
-  RUBY_WHITELIST = {
-    # FIXME: hack -- Relation.attributes currently implemented in marty
-    attributes:         [[ActiveRecord::Base, ActiveRecord::Relation]],
-    between?:           [NUM_OR_STR, NUM_OR_STR, NUM_OR_STR],
-    between:            "between?",
-    compact:            [[Array, Hash]],
-    to_set:             [Array],
-    flatten:            [Array, NUM_OR_NIL],
-    length:             [[String, Enumerable]],
-    max:                [Array],
-    member:             "member?",
-    member?:            [Enumerable, [Object]],
-    empty:              "empty?",
-    empty?:             [Enumerable],
-    except:             [Hash, String] + [[nil, String]]*9,
-    reverse:            [Array],
-    slice:              [Array, Integer, Integer],
-    each_slice:         [Array, Integer],
-    sort:               [Array],
-    split:              [String, String],
-    uniq:               [Array],
-    sum:                [Array],
-    transpose:          [Array],
-    join:               [Array, String],
-    zip:                [Array, Array, [Array, nil], [Array, nil]],
-    index:              [Array, [Object]],
-    product:            [Array, Array],
-    first:              [[ActiveRecord::Relation, Enumerable], NUM_OR_NIL],
-    last:               [[ActiveRecord::Relation, Enumerable], NUM_OR_NIL],
-    intersection:       [Set, Enumerable],
-    union:              [Set, Enumerable],
-
-    keys:               [Hash],
-    values:             [Hash],
-    fetch:              [Hash, Object, [Object]],
-    upcase:             [String],
-    downcase:           [String],
-    match:              [String, [String], NUM_OR_NIL],
-
-    iso8601:            [DT_TYPES],
-    hour:               [DT_TYPES],
-    min:                [DT_TYPES+[Array]],
-    sec:                [DT_TYPES],
-    to_date:            [DT_TYPES+[String]],
-    to_time:            [DT_TYPES+[String]],
-
-    month:              [DT_TYPES],
-    day:                [DT_TYPES],
-    year:               [DT_TYPES],
-
-    next_month:         [DT_TYPES, NUM_OR_NIL],
-    prev_month:         [DT_TYPES, NUM_OR_NIL],
-
-    beginning_of_month: [DT_TYPES],
-    end_of_month:       [DT_TYPES],
-
-    next_day:           [DT_TYPES, NUM_OR_NIL],
-    prev_day:           [DT_TYPES, NUM_OR_NIL],
-
-    to_i:               [NUM_OR_STR + TI_TYPES],
-    to_f:               [NUM_OR_STR + TI_TYPES],
-    to_d:               [NUM_OR_STR],
-    to_s:               [Object],
-    to_a:               [Object],
-    to_json:            [Object],
-    abs:                [Numeric],
-    round:              [Numeric, [nil, Integer]],
-    ceil:               [Numeric],
-    floor:              [Numeric],
-    truncate:           [Numeric, [nil, Integer]],
-  }
+  ::Delorean::Cache.adapter = ::Delorean::Cache::Adapters::RubyCache.new(size_per_class: 1000)
 
   module BaseModule
     # _e is used by Marty promise_jobs to pass promise-related
@@ -233,33 +156,23 @@ module Delorean
         end
 
         # FIXME: this is pretty hacky -- should probably merge
-        # RUBY_WHITELIST and SIG mechanisms.
+        # whitelist and SIG mechanisms.
         if obj.is_a?(Class)
           _e[:_engine].parse_check_call_fn(method, args.count, obj)
           return obj.send(msg, *args)
         end
 
         cls = obj.class
-        sig = RUBY_WHITELIST[msg]
-
-        raise "no such method #{method}" unless sig
 
-        # if sig is a string, then method mapped to another name
-        return _instance_call(obj, sig, args, _e) if sig.is_a? String
+        matcher = ::Delorean::Ruby.whitelist.matcher(method_name: msg)
 
-        raise "too many args to #{method}" if args.length>(sig.length-1)
+        raise "no such method #{method}" unless matcher
 
-        arglist = [obj] + args
+        return(
+          _instance_call(obj, matcher.match_to, args, _e)
+        ) if matcher.match_to?
 
-        sig.each_with_index do |s, i|
-          s = [s] unless s.is_a?(Array)
-
-          ai = arglist[i]
-
-          raise "bad arg #{i}, method #{method}: #{ai}/#{ai.class} #{s}" unless
-            (s.member?(nil) && i>=arglist.length) ||
-            s.detect {|sc| sc && ai.class <= sc}
-        end
+        matcher.match!(klass: obj.class, args: args)
 
         obj.send(msg, *args)
       end

data/lib/delorean/model.rb

@@ -34,15 +34,15 @@ module Delorean
       # large lists which we count as one item in the cache.  Caching
       # mechanism will result in large processes.
       def cached_delorean_fn(name, options = {}, &block)
-        delorean_fn(name, options) do |args|
+        delorean_fn(name, options) do |*args|
           delorean_cache_adapter = ::Delorean::Cache.adapter
           # Check if caching should be performed
-          next block.call(args) unless delorean_cache_adapter.cache_item?(
+          next block.call(*args) unless delorean_cache_adapter.cache_item?(
             klass: self, method_name: name, args: args
           )
 
           cache_key = delorean_cache_adapter.cache_key(
-            klass: self, method_name: name, args: [args]
+            klass: self, method_name: name, args: args
           )
           cached_item = delorean_cache_adapter.fetch_item(
             klass: self, cache_key: cache_key
@@ -50,7 +50,7 @@ module Delorean
 
           next cached_item if cached_item
 
-          res = block.call(args)
+          res = block.call(*args)
 
           delorean_cache_adapter.cache_item(
             klass: self, cache_key: cache_key, item: res

data/lib/delorean/ruby.rb

@@ -0,0 +1,13 @@
+require 'delorean/ruby/whitelists'
+
+module Delorean
+  module Ruby
+    def self.whitelist=(new_whitelist)
+      @whitelist = new_whitelist
+    end
+
+    def self.whitelist
+      @whitelist
+    end
+  end
+end

data/lib/delorean/ruby/whitelists.rb

@@ -0,0 +1,8 @@
+require 'delorean/ruby/whitelists/default'
+
+module Delorean
+  module Ruby
+    module Whitelists
+    end
+  end
+end

data/lib/delorean/ruby/whitelists/base.rb

@@ -0,0 +1,72 @@
+require 'delorean/ruby/whitelists/whitelist_error'
+require 'delorean/ruby/whitelists/matchers'
+
+module Delorean
+  module Ruby
+    module Whitelists
+      class Base
+        attr_reader :matchers
+
+        def add_method(method_name, match_to: nil, &block)
+          return method_name_error unless method_name.is_a?(Symbol)
+          return block_and_match_error if !match_to.nil? && block_given?
+
+          return add_matched_method(
+            method_name: method_name, match_to: match_to
+          ) unless match_to.nil?
+
+          matchers[method_name.to_sym] = method_matcher_class.new(
+            method_name: method_name, &block
+          )
+        end
+
+        def matcher(method_name:)
+          matchers[method_name.to_sym]
+        end
+
+        private
+
+        def initialize
+          @matchers = {}
+          initialize_hook
+        end
+
+        def add_matched_method(method_name:, match_to:)
+          correct_match_to = match_to.is_a?(String) || match_to.is_a?(Symbol)
+          return wrong_match_to_error unless correct_match_to
+
+          matcher = ::Delorean::Ruby::Whitelists::Matchers::Method.new(
+            method_name: method_name, match_to: match_to.to_sym
+          )
+
+          matchers[method_name.to_sym] = matcher
+        end
+
+        def block_and_match_error
+          raise(
+            ::Delorean::Ruby::Whitelists::WhitelistError,
+            'Method can not receive match_to and a block the same time'
+          )
+        end
+
+        def wrong_match_to_error
+          raise(
+            ::Delorean::Ruby::Whitelists::WhitelistError,
+            'match_to should either be a string or a symbol'
+          )
+        end
+
+        def method_name_error
+          raise(
+            ::Delorean::Ruby::Whitelists::WhitelistError,
+            'First attribute of add_method should be a symbol'
+          )
+        end
+
+        def method_matcher_class
+          ::Delorean::Ruby::Whitelists::Matchers::Method
+        end
+      end
+    end
+  end
+end

data/lib/delorean/ruby/whitelists/default.rb

@@ -0,0 +1,304 @@
+require 'delorean/ruby/whitelists/base'
+
+module Delorean
+  module Ruby
+    module Whitelists
+      class Default < ::Delorean::Ruby::Whitelists::Base
+        TI_TYPES   = [Time, ActiveSupport::TimeWithZone]
+        DT_TYPES   = [Date] + TI_TYPES
+        NUM_OR_STR = [Numeric, String]
+        NUM_OR_NIL = [nil, Integer]
+
+        def initialize_hook
+          _add_default_methods
+        end
+
+        private
+
+        def _add_default_methods
+          add_method :attributes do |method|
+            method.called_on ActiveRecord::Base
+            method.called_on ActiveRecord::Relation
+          end
+
+          add_method :between? do |method|
+            method.called_on String, with: [String, String]
+            method.called_on Numeric, with: [Numeric, Numeric]
+          end
+
+          add_method :between, match_to: :between?
+
+          add_method :compact do |method|
+            method.called_on Array
+            method.called_on Hash
+          end
+
+          add_method :to_set do |method|
+            method.called_on Array
+          end
+
+          add_method :flatten do |method|
+            method.called_on Array, with: [NUM_OR_NIL]
+          end
+
+          add_method :length do |method|
+            method.called_on String
+            method.called_on Enumerable
+          end
+
+          add_method :max do |method|
+            method.called_on Array
+          end
+
+          add_method :member, match_to: :member?
+
+          add_method :member? do |method|
+            method.called_on Enumerable, with: [Object]
+          end
+
+          add_method :empty, match_to: :empty?
+
+          add_method :empty? do |method|
+            method.called_on Enumerable
+          end
+
+          add_method :except do |method|
+            method.called_on Hash, with: [String] + [[nil, String]]*9
+          end
+
+          add_method :reverse do |method|
+            method.called_on Array
+          end
+
+          add_method :slice do |method|
+            method.called_on Array, with: [Integer, Integer]
+          end
+
+          add_method :each_slice do |method|
+            method.called_on Array, with: [Integer]
+          end
+
+          add_method :sort do |method|
+            method.called_on Array
+          end
+
+          add_method :split do |method|
+            method.called_on String, with: [String]
+          end
+
+          add_method :uniq do |method|
+            method.called_on Array
+          end
+
+          add_method :sum do |method|
+            method.called_on Array
+          end
+
+          add_method :transpose do |method|
+            method.called_on Array
+          end
+
+          add_method :join do |method|
+            method.called_on Array, with: [String]
+          end
+
+          add_method :zip do |method|
+            method.called_on Array, with: [Array, [Array, nil], [Array, nil]]
+          end
+
+          add_method :index do |method|
+            method.called_on Array, with: [[Object]]
+          end
+
+          add_method :product do |method|
+            method.called_on Array, with: [Array]
+          end
+
+          add_method :first do |method|
+            method.called_on ActiveRecord::Relation, with: [NUM_OR_NIL]
+            method.called_on Enumerable, with: [NUM_OR_NIL]
+          end
+
+          add_method :last do |method|
+            method.called_on ActiveRecord::Relation, with: [NUM_OR_NIL]
+            method.called_on Enumerable, with: [NUM_OR_NIL]
+          end
+
+          add_method :intersection do |method|
+            method.called_on Set, with: [Enumerable]
+          end
+
+          add_method :union do |method|
+            method.called_on Set, with: [Enumerable]
+          end
+
+
+
+          add_method :keys do |method|
+            method.called_on Hash
+          end
+
+          add_method :values do |method|
+            method.called_on Hash
+          end
+
+          add_method :fetch do |method|
+            method.called_on Hash, with: [Object, [Object]]
+          end
+
+          add_method :upcase do |method|
+            method.called_on String
+          end
+
+          add_method :downcase do |method|
+            method.called_on String
+          end
+
+          add_method :match do |method|
+            method.called_on String, with: [[String], NUM_OR_NIL]
+          end
+
+          add_method :iso8601 do |method|
+            DT_TYPES.each do |type|
+              method.called_on type
+            end
+          end
+
+          add_method :hour do |method|
+            DT_TYPES.each do |type|
+              method.called_on type
+            end
+          end
+
+          add_method :min do |method|
+            (DT_TYPES + [Array]).each do |type|
+              method.called_on type
+            end
+          end
+
+          add_method :sec do |method|
+            DT_TYPES.each do |type|
+              method.called_on type
+            end
+          end
+
+          add_method :to_date do |method|
+            (DT_TYPES + [String]).each do |type|
+              method.called_on type
+            end
+          end
+
+          add_method :to_time do |method|
+            (DT_TYPES + [String]).each do |type|
+              method.called_on type
+            end
+          end
+
+          add_method :month do |method|
+            DT_TYPES.each do |type|
+              method.called_on type
+            end
+          end
+
+          add_method :day do |method|
+            DT_TYPES.each do |type|
+              method.called_on type
+            end
+          end
+
+          add_method :year do |method|
+            DT_TYPES.each do |type|
+              method.called_on type
+            end
+          end
+
+          add_method :next_month do |method|
+            DT_TYPES.each do |type|
+              method.called_on type, with: [NUM_OR_NIL]
+            end
+          end
+
+          add_method :prev_month do |method|
+            DT_TYPES.each do |type|
+              method.called_on type, with: [NUM_OR_NIL]
+            end
+          end
+
+          add_method :beginning_of_month do |method|
+            DT_TYPES.each do |type|
+              method.called_on type
+            end
+          end
+
+          add_method :end_of_month do |method|
+            DT_TYPES.each do |type|
+              method.called_on type
+            end
+          end
+
+          add_method :next_day do |method|
+            DT_TYPES.each do |type|
+              method.called_on type, with: [NUM_OR_NIL]
+            end
+          end
+
+          add_method :prev_day do |method|
+            DT_TYPES.each do |type|
+              method.called_on type, with: [NUM_OR_NIL]
+            end
+          end
+
+          add_method :to_i do |method|
+            (NUM_OR_STR + TI_TYPES).each do |type|
+              method.called_on type
+            end
+          end
+
+          add_method :to_f do |method|
+            (NUM_OR_STR + TI_TYPES).each do |type|
+              method.called_on type
+            end
+          end
+
+          add_method :to_d do |method|
+            NUM_OR_STR.each do |type|
+              method.called_on type
+            end
+          end
+
+          add_method :to_s do |method|
+            method.called_on Object
+          end
+
+          add_method :to_a do |method|
+            method.called_on Object
+          end
+
+          add_method :to_json do |method|
+            method.called_on Object
+          end
+
+          add_method :abs do |method|
+            method.called_on Numeric
+          end
+
+          add_method :round do |method|
+            method.called_on Numeric, with: [[nil, Integer]]
+          end
+
+          add_method :ceil do |method|
+            method.called_on Numeric
+          end
+
+          add_method :floor do |method|
+            method.called_on Numeric
+          end
+
+          add_method :truncate do |method|
+            method.called_on Numeric, with: [[nil, Integer]]
+          end
+        end
+      end
+    end
+  end
+end

data/lib/delorean/ruby/whitelists/empty.rb

@@ -0,0 +1,12 @@
+require 'delorean/ruby/whitelists/base'
+
+module Delorean
+  module Ruby
+    module Whitelists
+      class Empty < ::Delorean::Ruby::Whitelists::Base
+        def initialize_hook
+        end
+      end
+    end
+  end
+end

data/lib/delorean/ruby/whitelists/matchers.rb

@@ -0,0 +1,10 @@
+require 'delorean/ruby/whitelists/matchers/method'
+
+module Delorean
+  module Ruby
+    module Whitelists
+      module Matchers
+      end
+    end
+  end
+end

data/lib/delorean/ruby/whitelists/matchers/arguments.rb

@@ -0,0 +1,47 @@
+module Delorean
+  module Ruby
+    module Whitelists
+      module Matchers
+        class Arguments
+          attr_reader :called_on, :method_name, :with
+
+          def initialize(called_on:, method_name:, with: [])
+            @called_on = called_on
+            @method_name = method_name
+            @with = with
+          end
+
+          def match!(args:)
+            raise "too many args to #{method_name}" if args.size > with.size
+
+            with.each_with_index do |s, i|
+              arg_signature = Array(s)
+
+              arg = args[i]
+
+              # Sometimes signature contains extra elements that can be nil.
+              # In that case we allow it to not be passed.
+              # For example .first and .first(4)
+              next if arg_signature.member?(nil) && i >= args.size
+
+              next if valid_argument?(arg_signature: arg_signature, arg: arg)
+
+              bad_arg_error(arg_signature: arg_signature, index: i, arg: arg)
+            end
+          end
+
+          private
+
+          def valid_argument?(arg_signature:, arg:)
+            arg_signature.any? { |sc| sc && arg.class <= sc }
+          end
+
+          def bad_arg_error(arg_signature:, index:, arg:)
+            arg_error = "#{arg}/#{arg.class} #{arg_signature}"
+            raise "bad arg #{index}, method #{method_name}: #{arg_error}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/delorean/ruby/whitelists/matchers/method.rb

@@ -0,0 +1,46 @@
+require 'delorean/ruby/whitelists/matchers/arguments'
+
+module Delorean
+  module Ruby
+    module Whitelists
+      module Matchers
+        class Method
+          attr_reader :method_name, :match_to, :arguments_matchers
+
+          def initialize(method_name:, match_to: nil)
+            @method_name = method_name
+            @match_to = match_to
+            @arguments_matchers = []
+
+            yield self if block_given?
+          end
+
+          def called_on(klass, with: [])
+            matcher = Ruby::Whitelists::Matchers::Arguments.new(
+              called_on: klass, method_name: method_name, with: with
+            )
+
+            arguments_matchers << matcher
+          end
+
+          def matcher(klass:)
+            matcher = arguments_matchers.find do
+              |matcher_object| klass <= matcher_object.called_on
+            end
+
+            raise "no such method #{method_name} for #{klass}" if matcher.nil?
+            matcher
+          end
+
+          def match!(klass:, args:)
+            matcher(klass: klass).match!(args: args)
+          end
+
+          def match_to?
+            !match_to.nil?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/delorean/ruby/whitelists/whitelist_error.rb

@@ -0,0 +1,8 @@
+module Delorean
+  module Ruby
+    module Whitelists
+      class WhitelistError < StandardError
+      end
+    end
+  end
+end

data/lib/delorean/version.rb

@@ -1,3 +1,3 @@
 module Delorean
-  VERSION = "0.4.7"
+  VERSION = "0.4.8"
 end

data/lib/delorean_lang.rb

@@ -1,12 +1,13 @@
 require "delorean/version"
 
 require 'treetop'
-require 'delorean/cache'
+require 'delorean/abstract_container'
+require 'delorean/base'
+require 'delorean/debug'
 require 'delorean/delorean'
-require 'delorean/nodes'
+require 'delorean/cache'
 require 'delorean/engine'
-require 'delorean/base'
 require 'delorean/error'
-require 'delorean/container'
 require 'delorean/model'
-require 'delorean/debug'
+require 'delorean/nodes'
+require 'delorean/ruby'

data/spec/cache_spec.rb

@@ -15,8 +15,8 @@ describe "Delorean cache" do
   it 'uses cache' do
     expect(OpenStruct).to receive(:new).once.and_call_original
 
-    res1 = Dummy.returns_cached_openstruct
-    res2 = Dummy.returns_cached_openstruct
+    res1 = Dummy.returns_cached_openstruct(1, 2)
+    res2 = Dummy.returns_cached_openstruct(1, 2)
 
     expect(res1).to eq res2
   end
@@ -31,8 +31,8 @@ describe "Delorean cache" do
   it "doesn't use cache with different keys" do
     expect(OpenStruct).to receive(:new).twice.and_call_original
 
-    Dummy.returns_cached_openstruct(1)
-    Dummy.returns_cached_openstruct(2)
+    Dummy.returns_cached_openstruct(1, 1)
+    Dummy.returns_cached_openstruct(1, 2)
   end
 
   it 'removes outdated items from cache' do
@@ -41,15 +41,15 @@ describe "Delorean cache" do
     )
 
     12.times do |t|
-      Dummy.returns_cached_openstruct(t)
+      Dummy.returns_cached_openstruct(t, t)
     end
 
     item_2 = ::Delorean::Cache.adapter.fetch_item(
-      klass: Dummy, cache_key: [:returns_cached_openstruct, 2]
+      klass: Dummy, cache_key: [:returns_cached_openstruct, 2, 2]
     )
 
     item_10 = ::Delorean::Cache.adapter.fetch_item(
-      klass: Dummy, cache_key: [:returns_cached_openstruct, 10]
+      klass: Dummy, cache_key: [:returns_cached_openstruct, 10, 10]
     )
 
     expect(item_2).to_not be_present

data/spec/func_spec.rb

@@ -268,12 +268,23 @@ describe "Delorean" do
   it "should handle BETWEEN" do
     engine.parse defn("A:",
                       "    a = 1.23",
-                      "    b = [a.between(10,20), a.between(1,3)]",
+                      "    number_between = [a.between(10,20), a.between(1,3)]",
+
+                      "    c = 'c'",
+                      "    string_between = [c.between('a', 'd'), c.between('d', 'e')]",
+
+                      "    types_mismatch1 = [a.between('a', 'd')]",
+                      "    types_mismatch2 = [c.between(1, 3)]"
                       )
 
-    expect(engine.evaluate("A", "b")).to eq([false, true])
+    expect(engine.evaluate("A", "number_between")).to eq([false, true])
+    expect(engine.evaluate("A", "string_between")).to eq([true, false])
+
+    expect { engine.evaluate("A", "types_mismatch1") }.to raise_error(/bad arg/)
+    expect { engine.evaluate("A", "types_mismatch2") }.to raise_error(/bad arg/)
   end
 
+
   it "should handle MATCH" do
     engine.parse defn("A:",
                       "    a = 'this is a test'.match('(.*)( is )(.*)')",
@@ -283,4 +294,5 @@ describe "Delorean" do
     expect(engine.evaluate("A", "b")).
       to eq(["this is a test", "this", " is ", "a test", nil])
   end
+
 end

data/spec/ruby/whitelist_spec.rb

@@ -0,0 +1,76 @@
+require_relative '../spec_helper'
+require 'delorean/ruby/whitelists/empty'
+
+describe "Delorean Ruby whitelisting" do
+  it 'allows to override whitelist with an empty one' do
+    ::Delorean::Ruby.whitelist = whitelist
+    expect(whitelist.matchers).to be_empty
+
+    ::Delorean::Ruby.whitelist = ::Delorean::Ruby::Whitelists::Default.new
+    expect(::Delorean::Ruby.whitelist.matchers).to_not be_empty
+  end
+
+  let(:whitelist) { ::Delorean::Ruby::Whitelists::Empty.new }
+
+  describe "methods" do
+    before do
+      whitelist.add_method :testmethod do |method|
+        method.called_on Dummy
+      end
+
+      whitelist.add_method :testmethod_with_args do |method|
+        method.called_on Dummy, with: [Numeric, [String, nil], [String, nil]]
+      end
+    end
+
+    let(:matcher) { whitelist.matcher(method_name: :testmethod) }
+    let(:matcher_with_args) do
+      whitelist.matcher(method_name: :testmethod_with_args)
+    end
+
+    it 'matches method' do
+      matcher = whitelist.matcher(method_name: :testmethod)
+      expect(matcher).to_not be_nil
+      expect { matcher.match!(klass: Dummy, args: []) }.to_not raise_error
+    end
+
+    it 'allows missing nillable arguments' do
+      expect do
+        matcher_with_args.match!(klass: Dummy, args: [1])
+      end.to_not raise_error
+    end
+
+    it 'raises error if method not allowed for a class' do
+      expect do
+        matcher.match!(klass: Date, args: [])
+      end.to raise_error('no such method testmethod for Date')
+    end
+
+    it 'raises error if arguments list is too long' do
+      expect do matcher.match!(klass: Dummy, args: [1])
+      end.to raise_error('too many args to testmethod')
+    end
+
+    it 'raises error if arguments list is too short' do
+      expect do
+        matcher_with_args.match!(klass: Dummy, args: [])
+      end.to raise_error(
+        'bad arg 0, method testmethod_with_args: /NilClass [Numeric]'
+      )
+    end
+
+    it 'raises error if argument type is wrong' do
+      expect do
+        matcher_with_args.match!(klass: Dummy, args: [1, 2])
+      end.to raise_error(
+        'bad arg 1, method testmethod_with_args: 2/Fixnum [String, nil]'
+      )
+    end
+
+    it 'allows match one method to another' do
+      whitelist.add_method :testmethod_matched, match_to: :testmethod_with_args
+      matcher = whitelist.matcher(method_name: :testmethod_matched)
+      expect(matcher.match_to?).to be true
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -88,8 +88,8 @@ class Dummy < ActiveRecord::Base
     OpenStruct.new({"abc"=>"def"})
   end
 
-  cached_delorean_fn :returns_cached_openstruct, sig: 1 do |ts = nil|
-    OpenStruct.new({"abc"=>"def"})
+  cached_delorean_fn :returns_cached_openstruct, sig: 2 do |first, last|
+    OpenStruct.new({ first.to_s => last })
   end
 end
 
@@ -115,10 +115,9 @@ module M
   end
 end
 
-Delorean::RUBY_WHITELIST.
-  merge!(
-         name2: [Dummy],
-         )
+Delorean::Ruby.whitelist.add_method :name2 do |method|
+  method.called_on Dummy
+end
 
 ######################################################################
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: delorean_lang
 version: !ruby/object:Gem::Version
-  version: 0.4.7
+  version: 0.4.8
 platform: ruby
 authors:
 - Arman Bostani
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-01-08 00:00:00.000000000 Z
+date: 2019-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: treetop
@@ -95,13 +95,13 @@ files:
 - README.md
 - Rakefile
 - delorean.gemspec
+- lib/delorean/abstract_container.rb
 - lib/delorean/base.rb
 - lib/delorean/cache.rb
 - lib/delorean/cache/adapters.rb
 - lib/delorean/cache/adapters/base.rb
 - lib/delorean/cache/adapters/ruby_cache.rb
 - lib/delorean/const.rb
-- lib/delorean/container.rb
 - lib/delorean/debug.rb
 - lib/delorean/delorean.rb
 - lib/delorean/delorean.treetop
@@ -109,6 +109,15 @@ files:
 - lib/delorean/error.rb
 - lib/delorean/model.rb
 - lib/delorean/nodes.rb
+- lib/delorean/ruby.rb
+- lib/delorean/ruby/whitelists.rb
+- lib/delorean/ruby/whitelists/base.rb
+- lib/delorean/ruby/whitelists/default.rb
+- lib/delorean/ruby/whitelists/empty.rb
+- lib/delorean/ruby/whitelists/matchers.rb
+- lib/delorean/ruby/whitelists/matchers/arguments.rb
+- lib/delorean/ruby/whitelists/matchers/method.rb
+- lib/delorean/ruby/whitelists/whitelist_error.rb
 - lib/delorean/version.rb
 - lib/delorean_lang.rb
 - spec/cache_spec.rb
@@ -116,6 +125,7 @@ files:
 - spec/eval_spec.rb
 - spec/func_spec.rb
 - spec/parse_spec.rb
+- spec/ruby/whitelist_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/arman000/delorean_lang
 licenses:
@@ -147,4 +157,5 @@ test_files:
 - spec/eval_spec.rb
 - spec/func_spec.rb
 - spec/parse_spec.rb
+- spec/ruby/whitelist_spec.rb
 - spec/spec_helper.rb

data/lib/delorean/container.rb

@@ -1,7 +0,0 @@
-require 'delorean/base'
-
-class Delorean::AbstractContainer
-  def get_engine(name)
-    raise "get_engine needs to be overriden"
-  end
-end