delorean_lang 0.4.6 → 0.4.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: c5f384dcfb07455b430f7e5cc39832349e90102061dd4938ae1c91b87705cd01
-  data.tar.gz: 53cc908c85b3ee1a22254aadc4e20994fd41d49b9dc1997de49faba053348b53
+SHA1:
+  metadata.gz: f606ebe7eea8de6ef41dcc2de653b09ed4177308
+  data.tar.gz: b545ce6a844aa31945cd590f73a456a23c68e613
 SHA512:
-  metadata.gz: af272886e5cfff2facfec56ec8a7b4e4b49453752740b07b45aff6ab1d2e47359707a04d7451e89bc7f58bd9752a4cdc88a859ed4299fee4de23eab96dc98774
-  data.tar.gz: ce15844ba019fa48b70ec47ed9fbe6f22956309375dd297a0cdab0ae289d5d663d0ad037cc82cb61f59de9014c570ad322d96240723aa17b94d1b63184c50d57
+  metadata.gz: d934f9c0172103dc572132b42ca728749801d50a3f63e87574d4788c09c995f4a475aaa9c96ebfc6f430732190fc2dd059e285587a9b53f1a406bb65d09289d0
+  data.tar.gz: 87ce61ccb1bce7c5e89df4bb8d0b975adcc4297cfaa8b913c5f318a02cee2d9b658479b446e81c13b73490d26a7d1429387a9d0053cefd26f0beb3e6df19d974

data/README.md

@@ -26,9 +26,9 @@ Or add it to your `Gemfile`, etc.
     NodeB: NodeA
         attr3 = attr1 / NodeA.attr3
     eom
-    
+
     engine.parse my_code
-    
+
     engine.evaluate("NodeB", %w{attr1 attr2 attr3})
 
 ## The Delorean Language
@@ -73,7 +73,7 @@ Therefore, in the above example, `NodeA.attr2` evaluates to `246`.
 Delorean attribute definitions have the following form:
 
 	attr = expression
-	
+
 Where `attr` is an attribute name. Attribute names are required to
 match the following regular expression: `[a-z][a-zA-Z0-9_]*`. An
 attribute can only be specified once in a node.  Also, any attributes
@@ -111,7 +111,7 @@ nodes.  The following example shows the usage of inheritance:
 
     IndiaInfo: USInfo
 		teen_min = 10
-		
+
 In this example, node `USInfo` provides a definition of a
 `is_teenager` when provided with an `age` parameter. Node `IndiaInfo`
 is derived from `USInfo` and so it shares all of its attribute
@@ -135,6 +135,51 @@ TODO: provide details on the following topics:
 This implementation of Delorean "compiles" script code to
 Ruby.
 
+### Caching
+
+Delorean provides `cached_delorean_function` method that will cache result based on arguments.
+
+```ruby
+  cached_delorean_fn :returns_cached_openstruct, sig: 1 do |timestamp|
+    User.all
+  end
+
+```
+
+If `::Delorean::Cache.adapter.cache_item?(...)` returns `false` then caching will not be performed.
+
+By default cache keeps the last 1000 of the results per class. You can override it:
+
+```ruby
+
+  ::Delorean::Cache.adapter = ::Delorean::Cache::Adapters::RubyCache.new(size_per_class: 10)
+
+```
+
+If you want use other caching method, you can use your own adapter:
+
+```ruby
+
+  ::Delorean::Cache.adapter = ::My::Custom::Cache::Adapter.new
+
+```
+
+Delorean expects it to have methods with following signatures:
+
+```ruby
+
+  cache_item(klass:, cache_key:, item:)
+  fetch_item(klass:, cache_key:)
+  cache_key(klass:, method_name:, args:)
+  clear!(klass:)
+  clear_all!
+  cache_item?(klass:, method_name:, args:)
+
+  # See lib/delorean/cache/adapters/base.rb
+
+```
+
+
 TODO: provide details
 
 ## License

data/lib/delorean/base.rb

@@ -1,9 +1,12 @@
 require 'active_support/time'
 require 'active_record'
 require 'bigdecimal'
+require 'delorean/cache'
 
 module Delorean
 
+  ::Delorean::Cache.adapter = ::Delorean::Cache::Adapters::RubyCache.new(size_per_class: 1000)
+
   TI_TYPES   = [Time, ActiveSupport::TimeWithZone]
   DT_TYPES   = [Date] + TI_TYPES
   NUM_OR_STR = [Numeric, String]

data/lib/delorean/cache/adapters/base.rb

@@ -0,0 +1,33 @@
+module Delorean
+  module Cache
+    module Adapters
+      class Base
+        def cache_item(klass:, cache_key:, args:)
+          raise 'cache_item is not implemented'
+        end
+
+        def fetch_item(klass:, cache_key:, args:)
+          raise 'fetch_item is not implemented'
+        end
+
+        def cache_key(klass:, method_name:, args:)
+          raise 'cache_key is not implemented'
+        end
+
+        def clear!(klass:)
+          raise 'clear! is not implemented'
+        end
+
+        def clear_all!
+          raise 'clear_all! is not implemented'
+        end
+
+        # Redefine this method in descendants
+        # to avoid caching calls with certain arguments
+        def cache_item?(klass:, method_name:, args:)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/delorean/cache/adapters/ruby_cache.rb

@@ -0,0 +1,54 @@
+require_relative './base'
+
+module Delorean
+  module Cache
+    module Adapters
+      class RubyCache < ::Delorean::Cache::Adapters::Base
+        attr_reader :lookup_cache, :size_per_class
+
+        def initialize(size_per_class: 1000)
+          @lookup_cache = {}
+          @size_per_class = size_per_class
+        end
+
+        def cache_item(klass:, cache_key:, item:)
+          lookup_cache[klass] ||= {}
+          clear_outdated_items(klass: klass)
+          lookup_cache[klass][cache_key] = item
+        end
+
+        def fetch_item(klass:, cache_key:)
+          lookup_cache.dig(klass, cache_key)
+        end
+
+        def cache_key(klass:, method_name:, args:)
+          [method_name] + args.map do |arg|
+            next arg.id if arg.respond_to?(:id)
+            arg
+          end.freeze
+        end
+
+        def clear!(klass:)
+          lookup_cache[klass] = {}
+        end
+
+        def clear_all!
+          @lookup_cache = {}
+        end
+
+        private
+
+        def clear_outdated_items(klass:)
+          cache_object = lookup_cache[klass]
+          return unless cache_object
+          return if cache_object.count < size_per_class
+
+          max_items = (size_per_class / 5).floor
+          cache_object.keys[0..max_items].each do |key|
+            cache_object.delete(key)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/delorean/cache/adapters.rb

@@ -0,0 +1,8 @@
+require 'delorean/cache/adapters/ruby_cache'
+
+module Delorean
+  module Cache
+    module Adapters
+    end
+  end
+end

data/lib/delorean/cache.rb

@@ -0,0 +1,13 @@
+require 'delorean/cache/adapters'
+
+module Delorean
+  module Cache
+    def self.adapter
+      @adapter
+    end
+
+    def self.adapter=(new_adapter)
+      @adapter = new_adapter
+    end
+  end
+end

data/lib/delorean/model.rb

@@ -22,6 +22,52 @@ module Delorean
           self.const_set(name.to_s.upcase+Delorean::SIG, sig)
         end
       end
+
+      # FIXME IDEA: we just make :cache an argument to delorean_fn.
+      # That way, we don't need the cached_ flavors.  It'll make all
+      # this code a lot simpler.  We should also just add the :private
+      # mechanism here.
+
+      # By default implements a VERY HACKY class-based (per process) caching
+      # mechanism for database lookup results.  Issues include: cached
+      # values are ActiveRecord objects.  Query results can be very
+      # 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_cache_adapter = ::Delorean::Cache.adapter
+          # Check if caching should be performed
+          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]
+          )
+          cached_item = delorean_cache_adapter.fetch_item(
+            klass: self, cache_key: cache_key
+          )
+
+          next cached_item if cached_item
+
+          res = block.call(args)
+
+          delorean_cache_adapter.cache_item(
+            klass: self, cache_key: cache_key, item: res
+          )
+
+          # Since we're caching this object and don't want anyone
+          # changing it.  FIXME: ideally should freeze this object
+          # recursively.
+          res.freeze if res.respond_to?(:freeze)
+
+          res
+        end
+      end
+
+      def clear_lookup_cache!
+        ::Delorean::Cache.adapter.clear!(klass: self)
+      end
     end
   end
 end

data/lib/delorean/version.rb

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

data/lib/delorean_lang.rb

@@ -1,6 +1,7 @@
 require "delorean/version"
 
 require 'treetop'
+require 'delorean/cache'
 require 'delorean/delorean'
 require 'delorean/nodes'
 require 'delorean/engine'

data/spec/cache_spec.rb

@@ -0,0 +1,58 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Delorean cache" do
+  before do
+    Dummy.clear_lookup_cache!
+  end
+
+  it 'allows to set adapter' do
+    ::Delorean::Cache.adapter = ::Delorean::Cache::Adapters::RubyCache.new(
+      size_per_class: 100
+    )
+    expect(::Delorean::Cache.adapter.size_per_class).to eq 100
+  end
+
+  it 'uses cache' do
+    expect(OpenStruct).to receive(:new).once.and_call_original
+
+    res1 = Dummy.returns_cached_openstruct
+    res2 = Dummy.returns_cached_openstruct
+
+    expect(res1).to eq res2
+  end
+
+  it 'clears cache' do
+    expect(OpenStruct).to receive(:new).twice.and_call_original
+    Dummy.returns_cached_openstruct
+    Dummy.clear_lookup_cache!
+    Dummy.returns_cached_openstruct
+  end
+
+  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)
+  end
+
+  it 'removes outdated items from cache' do
+    ::Delorean::Cache.adapter = ::Delorean::Cache::Adapters::RubyCache.new(
+      size_per_class: 10
+    )
+
+    12.times do |t|
+      Dummy.returns_cached_openstruct(t)
+    end
+
+    item_2 = ::Delorean::Cache.adapter.fetch_item(
+      klass: Dummy, cache_key: [:returns_cached_openstruct, 2]
+    )
+
+    item_10 = ::Delorean::Cache.adapter.fetch_item(
+      klass: Dummy, cache_key: [:returns_cached_openstruct, 10]
+    )
+
+    expect(item_2).to_not be_present
+    expect(item_10).to be_present
+  end
+end

data/spec/spec_helper.rb

@@ -4,6 +4,7 @@ $LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'rspec'
 require 'delorean_lang'
 require 'active_record'
+require 'pry'
 
 # Requires supporting files with custom matchers and macros, etc,
 # in ./support/ and its subdirectories.
@@ -86,6 +87,10 @@ class Dummy < ActiveRecord::Base
   delorean_fn :returns_openstruct, sig: 0 do
     OpenStruct.new({"abc"=>"def"})
   end
+
+  cached_delorean_fn :returns_cached_openstruct, sig: 1 do |ts = nil|
+    OpenStruct.new({"abc"=>"def"})
+  end
 end
 
 class DummyChild < Dummy

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: delorean_lang
 version: !ruby/object:Gem::Version
-  version: 0.4.6
+  version: 0.4.7
 platform: ruby
 authors:
 - Arman Bostani
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-11-05 00:00:00.000000000 Z
+date: 2019-01-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: treetop
@@ -96,6 +96,10 @@ files:
 - Rakefile
 - delorean.gemspec
 - 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
@@ -107,6 +111,7 @@ files:
 - lib/delorean/nodes.rb
 - lib/delorean/version.rb
 - lib/delorean_lang.rb
+- spec/cache_spec.rb
 - spec/dev_spec.rb
 - spec/eval_spec.rb
 - spec/func_spec.rb
@@ -132,11 +137,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.7.7
+rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
 summary: Delorean compiler
 test_files:
+- spec/cache_spec.rb
 - spec/dev_spec.rb
 - spec/eval_spec.rb
 - spec/func_spec.rb