active_memoize 1.1.1 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1385c5e7ddc821d41bbf56e62bd47280c920fce6ff108feadbd2d34aeba38194
-  data.tar.gz: 7ead9b7f7673973a62f092d427dc0635b8c685dfbcc032a615ce45a6a551a72f
+  metadata.gz: 91f66190445f2955c5905be5a7e0f5fce6a9842dbb5cc6b92755927cfe29f0b9
+  data.tar.gz: a1806275ccb0004f7260b5cb38d54f2651299216932eb4db1c52558baa7d6ede
 SHA512:
-  metadata.gz: '09e6ee6a1cdb35f3238514672b60a3a8c734fc7bbcac020e8d32f9c35a080fb5262e2df5112231b7e7d8daf8bab01e9aba3db27c90fc0bcd74d91bc83216ab1e'
-  data.tar.gz: 6e392c12c109d10a7819ae8a87acc18b2093a82c30c14d2202da29a055fa5ef8123499c6fdb0f82b8604093f175cb98f4d6bcb6812a32b12a8297f580af440aa
+  metadata.gz: 3f1e19d175f9e2ba0ca739737c88d347aadb9c8a7f7b8e00569593452384d8ac9d9ffec1e73975f0065bed362dddfb549ecff411795f8f236785eb20b9d9e4f8
+  data.tar.gz: 06fa2777ea5b110690dd16e55c6f6773a8c3b6aec1fb695c96cfedc9f31809ad812207f0044535eb4514fe456adcf0627270d74915dc65d22c9efdbbb120cf72

data/README.md

@@ -6,6 +6,9 @@
 ActiveMemoize provides an API caching and memoizing local
 expensive calculations including those with parameters.
 
+The flexible API allows you to memoize results using class
+or instance level cache.
+
 ## Installation
 
 Add this line to your application's Gemfile:
@@ -24,31 +27,55 @@ Or install it yourself as:
 
 ## Table of Contents
 
-* [Usage](#usage)
+* [Klass](#klass)
+* [Instance](#instance)
+
+## Klass
 
-## Usage
+Class level memoization is the quickest way to get up and running using your cache, but provides the least amount of flexibility. You can only cache results
+without access to any information about your cache.
+
+```ruby
+class Movies
+  extend ActiveMemoize::Klass
+
+  def random
+    HTTP.get('http://movies.com/any')
+  end
+
+  memoize :random
+
+  def search(title)
+    HTTP.get("http://movies.com?title=#{title}")
+  end
+
+  memoize :search, as: :find
+
+end
+```
+
+## Instance
+
+Instance level memoization is a more involved way to setup your cache, but provides the most amount of flexibility. You can access almost all methods
+in the `instance.rb` file.
 
 ```ruby
 class Movies
 
   def cache
-    @cache ||= ActiveMemoize::Cache.new
+    @cache ||= ActiveMemoize::Instance.new
   end
 
   def all
-    cache.memoize('custom_cache_key') do
-      HTTP.get("http://movies.com/all")
-    end
+    cache.memoize { HTTP.get("http://movies.com/all") }
   end
 
   def random
     cache['random'] ||= HTTP.get('http://movies.com/any')
   end
 
-  def search(title, force = false)
-    cache.clear if force
-
-    cache.memoize do
+  def search(title)
+    cache.memoize(as: :find, refresh: !cache.empty?) do
       HTTP.get("http://movies.com?title=#{title}")
     end
   end

data/lib/active_memoize.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-%w[version cache].each do |file_name|
+%w[version shared klass instance].each do |file_name|
   require "active_memoize/#{file_name}"
 end

data/lib/active_memoize/{cache.rb → instance.rb}

@@ -1,67 +1,60 @@
 # frozen_string_literal: true
 
 module ActiveMemoize
-  class Cache
+  class Instance
+    include ActiveMemoize::Shared
 
     CALLER_METHOD_REGEX ||= /`([^']*)'/.freeze
 
-    attr_reader :cache
-
-    def initialize
-      @cache = {}
-    end
+    def initialize; end
 
     def [](key)
-      @cache[key]
+      cache[key]
     end
 
     def []=(key, val)
-      @cache[key] = val
+      cache[key] = val
     end
 
     def clear
-      @cache.clear
+      cache.clear
     end
 
     def delete(key)
-      @cache.delete(key)
+      cache.delete(key)
     end
 
     # :nocov:
     def each
-      @cache.each { |key, val| yield(key, val) }
+      cache.each { |key, val| yield(key, val) }
     end
     # :nocov:
 
     def empty?
-      @cache.empty?
+      cache.empty?
     end
 
     alias_method :blank?, :empty?
 
     def key?(key)
-      @cache.key?(key)
+      cache.key?(key)
     end
 
     alias_method :hit?, :key?
 
     def keys
-      @cache.keys
+      cache.keys
     end
 
     def merge!(hash)
-      @cache.merge!(hash)
+      cache.merge!(hash)
     end
 
-    def memoize(method_name = nil, &block)
-      method_locals = caller_locals(block)
-      method_name ||= begin
-        method_locals.nil? ? caller_method : "#{caller_method}:#{method_locals}"
-      end
+    def memoize(as: nil, refresh: false, &block)
+      key = key(as || caller_method, caller_locals(block))
+      return cache[key] if !refresh && cache.key?(key)
 
-      return @cache[method_name] if @cache.key?(method_name)
-
-      @cache[method_name] = yield(block)
+      cache[key] = yield(block)
     end
 
     def present?
@@ -71,18 +64,18 @@ module ActiveMemoize
     alias_method :hits?, :present?
 
     def size
-      @cache.size
+      cache.size
     end
 
     def to_hash
-      @cache
+      cache
     end
 
     alias_method :as_json, :to_hash
     alias_method :hits, :to_hash
 
     def values
-      @cache.values
+      cache.values
     end
 
     private
@@ -90,10 +83,7 @@ module ActiveMemoize
     # rubocop:disable Metrics/LineLength
     def caller_locals(block)
       local_vars = block.binding.local_variables
-      local_vars = local_vars.flat_map { |name| [name, block.binding.local_variable_get(name)].join('=') }
-      return if local_vars.empty?
-
-      local_vars.join(',')
+      local_vars.flat_map { |name| [name, block.binding.local_variable_get(name)] }
     end
     # rubocop:enable Metrics/LineLength
 

data/lib/active_memoize/klass.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ActiveMemoize
+  module Klass
+    include ActiveMemoize::Shared
+
+    def memoize(method_name, as: nil)
+      inner_method = instance_method(method_name)
+
+      define_method(method_name) do |*args|
+        key = self.class.key(as || method_name, args)
+        self.class.cache[key] ||= inner_method.bind(self).call(*args)
+      end
+    end
+
+  end
+end

data/lib/active_memoize/shared.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'digest'
+
+module ActiveMemoize
+  module Shared
+
+    def cache
+      @cache ||= {}
+    end
+
+    def key(method_name, method_args)
+      Digest::SHA1.hexdigest("#{method_name}:#{method_args}")
+    end
+
+  end
+end

data/lib/active_memoize/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ActiveMemoize
-  VERSION ||= '1.1.1'
+  VERSION ||= '2.0.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_memoize
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 2.0.0
 platform: ruby
 authors:
 - Juan Gomez
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-03-18 00:00:00.000000000 Z
+date: 2019-03-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -118,7 +118,9 @@ files:
 - bin/rake
 - bin/setup
 - lib/active_memoize.rb
-- lib/active_memoize/cache.rb
+- lib/active_memoize/instance.rb
+- lib/active_memoize/klass.rb
+- lib/active_memoize/shared.rb
 - lib/active_memoize/version.rb
 homepage: http://drexed.github.io/active_memoize
 licenses: