lite-memoize 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ce750474bdced13fe1092158da39d598a7da547a2e6c8a756f2c9fbb20a42937
-  data.tar.gz: 57abad4fb181dadc17c22c0db81f8d7a1c02783bcdb25bd5906b98984285465d
+  metadata.gz: 2a2e51485362684ce1520b7eca9484106b5b83c9bc6336b2215dcffa6d56cfed
+  data.tar.gz: 43eb2cd5cb4330f12a503f3b66594b6a0c076bb1a0a991a0735bef1c11fd3cb6
 SHA512:
-  metadata.gz: 758011939ac4b1f398c3f5a290a0c09be7adec6a9c9480b294e5d5a8872ceccb7bdd9e301b5ac98110a0bde6d0ec4cd1599fe0b54fe62c390c25d1f171e2a413
-  data.tar.gz: 48cf101236f639ab626563f24213b47bb28799aaca4a157dd32611a2b2135ab54ca7040375ddb2ce82146c217636064cc492c0f40f853fba94757a9b4d3e186e
+  metadata.gz: b082b4804dbcedb965b006b0077375195316720d7397b5ed0140b5ae0de8847706d3503e8ca9f33f7c6ce064a0d79c2ff6f25a57a06e3a458ee2506e0f623436
+  data.tar.gz: 0dc03f302a930483a8ca51f114e80b6ed36506153bf1840f0ddcfb221404acd1f307dc77ae1dcf8f4a0a60970513d382954180cb70e49928d7727a41dcdcf48c

data/.rubocop.yml

@@ -11,13 +11,19 @@ Layout/EmptyLinesAroundBlockBody:
   Exclude:
     - 'spec/**/**/*'
 Layout/EmptyLinesAroundClassBody:
-  EnforcedStyle: empty_lines
+  EnforcedStyle: empty_lines_except_namespace
 Layout/EmptyLinesAroundModuleBody:
   EnforcedStyle: empty_lines_except_namespace
 Metrics/BlockLength:
   Exclude:
     - 'spec/**/**/*'
     - '*.gemspec'
+Metrics/ModuleLength:
+  Enabled: false
+Naming/FileName:
+  Enabled: false
+Naming/MemoizedInstanceVariableName:
+  Enabled: false
 Naming/UncommunicativeMethodParamName:
   Enabled: false
 Style/Documentation:

data/.travis.yml

@@ -1,20 +1,24 @@
----
 sudo: false
 language: ruby
 cache: bundler
 rvm:
-  - 2.5
-  - 2.6
-  - ruby-head
+- 2.5
+- 2.6
+- ruby-head
 matrix:
   fast_finish: true
   allow_failures:
-    - rvm: ruby-head
+  - rvm: ruby-head
 before_install:
-  - gem update --system
-  - gem install bundler
+- gem update --system
+- gem install bundler
 install:
-  - bundle install --jobs=3 --retry=3
+- bundle install --jobs=3 --retry=3
 script:
-  - bundle exec rspec
-  # - bundle exec fasterer
+- bundle exec rspec
+- bundle exec rubocop
+# - bundle exec fasterer
+notifications:
+  email: false
+  slack:
+    secure: AqhUTKwgANtYDGb/t49g7Ibvm9B7zgIOQXJSTRC4NXjWSE8xCJ7uYEH6EwmuBPK4/QfK81TgzSC74cQKmzQojpZnTjtHtdNzUbjJ07EKvlaywdRiFNlqs7WpKVs4MdqUd9UpX8f9KAKqZqEsVPmCNuFqApJ66wJiz0ab4tXKqcC8XDhpbzXSPlwhPXXwBUx5gBQZy/sOSWVhSZCJvLO6RwuShzUbA4wHBtMYuAfu5nhHdkK7Jq48aMy973Nh3zvPRTR2dt+25/DPWoDlXtZ6p6JvuTkuzkqsFm13pMH3maxTwZOESFbGD/eFAmeOtJkZuDAfWhajfMh1ESjr4ONRC7UFCXEMZFmAbd24xS57zF5C2de5eM8UFN3O9SEHa4VU3fYFsDOJPFeJoadeyrmkmpnlO4u/EvFH1qrB2wbLurNB7daI30BvQ0UflKE6hBW7TyeswP0o3g5y4fwJORCmG7symRiy9BDkj3LFaANQ7zz1LRabZliiD5ZiNLMiXQ8GLtQ6um1F91ZtX60qj0Qo7z16UJRdWJTkmJmneneJYoP/F5fgKmVRactX+24dEojKUFV9EsF6qOf2W9q5PiOjJ7Ja8O6ubpx3XrDWbZpq1zgJ3DWw7J40TxWzPHAHJRdg1fQ90AmyUMpwJ/4HoRuGD1w3VLeoK9+d9Nrx23FJX4Q=

data/CHANGELOG.md

@@ -6,6 +6,15 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.0.1] - 2019-07-18
+### Added
+- Added alias memoization
+- Added benchmarks
+### Changed
+- Improved speed of key generation and lookup for instance
+- Changed refresh arg to reload
+- Renamed shared to mixin
+
 ## [1.0.0] - 2019-06-24
 ### Added
 - Initial project version

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    lite-memoize (1.0.0)
+    lite-memoize (1.0.1)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -3,8 +3,7 @@
 [![Gem Version](https://badge.fury.io/rb/lite-memoize.svg)](http://badge.fury.io/rb/lite-memoize)
 [![Build Status](https://travis-ci.org/drexed/lite-memoize.svg?branch=master)](https://travis-ci.org/drexed/lite-memoize)
 
-Lite::Memoize provides an API for caching and memoizing locally expensive calculations including those with parameters.
-The flexible API allows you to memoize results using class or instance level cache.
+Lite::Memoize provides an API for caching and memoizing locally expensive calculations including those with parameters. The flexible API allows you to memoize results using alias, class, instance, or mixin level cache.
 
 **NOTE:** If you are coming from `ActiveMemoize`, please read the [port](#port) section.
 
@@ -26,21 +25,63 @@ Or install it yourself as:
 
 ## Table of Contents
 
-* [Port](#port)
+* [Alias](#alias)
 * [Klass](#klass)
 * [Instance](#instance)
+* [Mixin](#mixin)
+* [Benchmarks](#benchmarks)
+* [Port](#port)
 
-## Port
+## Alias
 
-`Lite::Memoize` is compatible port of [ActiveMemoize](https://github.com/drexed/active_memoize).
+Alias level memoization is the fastest of the available methods, and provides a decent level
+of control. It's the only one that can also be used to memoize class level methods. Method
+arguments are automatically watched to cache dynamic values.
 
-Switching is as easy as renaming `ActiveMemoize::Klass` to `Lite::Memoize::Klass`
-and  `ActiveMemoize::Instance` to `Lite::Memoize::Instance`.
+You can only cache results without access to any information about the `store`.
+
+```ruby
+class Movies
+  extend Lite::Memoize::Alias
+
+  class << self
+    extend Lite::Memoize::Alias
+
+    def random
+      HTTP.get('http://movies.com/any')
+    end
+
+    memoize :random
+  end
+
+  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
+
+# NOTE: To reload a method just append the reload argument key
+Movies.random               #=> Cached
+Movies.random(reload: true) #=> New value
+
+# NOTE: To flush the entire cache
+Movies.clear_cache #=> New value
+```
 
 ## Klass
 
-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.
+Class level memoization is the quickest way to get up without polluting your class with new methods.
+It's perfect for short lived or non-altering items like `activerecord` objects.
+
+You can only cache results without access to any information about the `store`.
 
 ```ruby
 class Movies
@@ -63,7 +104,12 @@ end
 
 ## Instance
 
-Instance level memoization is a more involved way to setup your cache, but provides the most amount of flexibility.
+Instance level memoization is the slowest of the available methods, but it provides
+the most amount of flexibility and control. It's very useful for creating services or things
+where control is paramount like clearing the cache or dumping it to JSON. Please read the spec
+suite to see all available actions. Method arguments are automatically watched to cache dynamic
+values.
+
 You can access almost all methods in the `instance.rb` file.
 
 ```ruby
@@ -73,16 +119,18 @@ class Movies
     @cache ||= Lite::Memoize::Instance.new
   end
 
+  # NOTE: This method gets all relevent info like name and args automatically
   def all
     cache.memoize { HTTP.get("http://movies.com/all") }
   end
 
-  def random
-    cache['random'] ||= HTTP.get('http://movies.com/any')
+  def random(type)
+    cache['random'] ||= HTTP.get("http://movies.com/any?type=#{type}")
   end
 
+  # NOTE: Arguments in the memoize method are optional
   def search(title)
-    cache.memoize(as: :find, refresh: !cache.empty?) do
+    cache.memoize(as: :find, args: [title], reload: !cache.empty?) do
       HTTP.get("http://movies.com?title=#{title}")
     end
   end
@@ -90,6 +138,44 @@ class Movies
 end
 ```
 
+## Mixin
+
+Mixin level memoization is the leanest of the available methods, and provides a decent level
+of control. Useful when you want to keep your class light weight.
+
+You can access all methods to the `Hash` class.
+
+```ruby
+class Movies
+  include Lite::Memoize::Mixin
+
+  def all
+    memoize(:all) { HTTP.get("http://movies.com/all") }
+  end
+
+  # NOTE: Arguments in the memoize method are optional with the exception of method name
+  def search(title)
+    memoize(:find, args: [title], reload: false) do
+      HTTP.get("http://movies.com?title=#{title}")
+    end
+  end
+
+end
+```
+
+## Benchmarks
+
+The classes ranked from fastest to slowest are `Alias`, `Mixin`, `Klass`, and `Instance`.
+
+View all how it compares to other libs by running the [benchmarks](https://github.com/drexed/lite-statistics/tree/master/benchmarks).
+
+## Port
+
+`Lite::Memoize` is a compatible port of [ActiveMemoize](https://github.com/drexed/active_memoize).
+
+Switching is as easy as renaming `ActiveMemoize::Klass` to `Lite::Memoize::Klass`
+and  `ActiveMemoize::Instance` to `Lite::Memoize::Instance`.
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.

data/benchmarks/base.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+%w[lib benchmarks].each { |name| $LOAD_PATH.unshift(name) }
+
+require 'benchmark/ips'
+require 'lite/memoize'
+
+class LiteMemoizeAliasCache
+
+  extend Lite::Memoize::Alias
+
+  def randomize
+    rand(1..99)
+  end
+
+  memoize :randomize
+
+end
+
+class LiteMemoizeInstanceCache
+
+  def cache
+    @cache ||= Lite::Memoize::Instance.new
+  end
+
+  def randomize
+    cache.memoize { rand(1..99) }
+  end
+
+end
+
+class LiteMemoizeKlassCache
+
+  extend Lite::Memoize::Klass
+
+  def randomize
+    rand(1..99)
+  end
+
+  memoize :randomize
+
+end
+
+class LiteMemoizeMixinCache
+
+  include Lite::Memoize::Mixin
+
+  def randomize
+    memoize(:randomize) { rand(1..99) }
+  end
+
+end

data/benchmarks/memery.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'memery'
+require_relative 'base'
+
+class MemeryCache
+
+  include Memery
+
+  memoize def randomize
+    rand(1..99)
+  end
+
+end
+
+klass_a = LiteMemoizeInstanceCache.new
+klass_b = LiteMemoizeKlassCache.new
+klass_c = LiteMemoizeMixinCache.new
+klass_d = LiteMemoizeAliasCache.new
+klass_z = MemeryCache.new
+
+Benchmark.ips do |x|
+  x.report('LM.instance') do
+    klass_a.randomize
+  end
+
+  x.report('LM.klass') do
+    klass_b.randomize
+  end
+
+  x.report('LM.mixin') do
+    klass_c.randomize
+  end
+
+  x.report('LM.alias') do
+    klass_d.randomize
+  end
+
+  x.report('Memery') do
+    klass_z.randomize
+  end
+
+  x.compare!
+end

data/benchmarks/memist.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'memist'
+require_relative 'base'
+
+class MemistCache
+
+  def randomize
+    rand(1..99)
+  end
+
+  memoize :randomize
+
+end
+
+klass_a = LiteMemoizeInstanceCache.new
+klass_b = LiteMemoizeKlassCache.new
+klass_c = LiteMemoizeMixinCache.new
+klass_d = LiteMemoizeAliasCache.new
+klass_z = MemistCache.new
+
+Benchmark.ips do |x|
+  x.report('LM.instance') do
+    klass_a.randomize
+  end
+
+  x.report('LM.klass') do
+    klass_b.randomize
+  end
+
+  x.report('LM.mixin') do
+    klass_c.randomize
+  end
+
+  x.report('LM.alias') do
+    klass_d.randomize
+  end
+
+  x.report('Memist') do
+    klass_z.randomize
+  end
+
+  x.compare!
+end

data/benchmarks/memo-it.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'memo/it'
+require_relative 'base'
+
+class MemoitCache
+
+  def randomize
+    memo do
+      rand(1..99)
+    end
+  end
+
+end
+
+klass_a = LiteMemoizeInstanceCache.new
+klass_b = LiteMemoizeKlassCache.new
+klass_c = LiteMemoizeMixinCache.new
+klass_d = LiteMemoizeAliasCache.new
+klass_z = MemoitCache.new
+
+Benchmark.ips do |x|
+  x.report('LM.instance') do
+    klass_a.randomize
+  end
+
+  x.report('LM.klass') do
+    klass_b.randomize
+  end
+
+  x.report('LM.mixin') do
+    klass_c.randomize
+  end
+
+  x.report('LM.alias') do
+    klass_d.randomize
+  end
+
+  x.report('Memoit') do
+    klass_z.randomize
+  end
+
+  x.compare!
+end

data/benchmarks/memoist.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'memoist'
+require_relative 'base'
+
+class MemoistCache
+
+  extend Memoist
+
+  def randomize
+    rand(1..99)
+  end
+
+  memoize :randomize
+
+end
+
+klass_a = LiteMemoizeInstanceCache.new
+klass_b = LiteMemoizeKlassCache.new
+klass_c = LiteMemoizeMixinCache.new
+klass_d = LiteMemoizeAliasCache.new
+klass_z = MemoistCache.new
+
+Benchmark.ips do |x|
+  x.report('LM.instance') do
+    klass_a.randomize
+  end
+
+  x.report('LM.klass') do
+    klass_b.randomize
+  end
+
+  x.report('LM.mixin') do
+    klass_c.randomize
+  end
+
+  x.report('LM.alias') do
+    klass_d.randomize
+  end
+
+  x.report('Memoist') do
+    klass_z.randomize
+  end
+
+  x.compare!
+end

data/benchmarks/memoist2.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'memoist2'
+require_relative 'base'
+
+class Memoist2Cache
+
+  include Memoist2
+
+  def randomize
+    rand(1..99)
+  end
+
+  memoize :randomize
+
+end
+
+klass_a = LiteMemoizeInstanceCache.new
+klass_b = LiteMemoizeKlassCache.new
+klass_c = LiteMemoizeMixinCache.new
+klass_d = LiteMemoizeAliasCache.new
+klass_z = Memoist2Cache.new
+
+Benchmark.ips do |x|
+  x.report('LM.instance') do
+    klass_a.randomize
+  end
+
+  x.report('LM.klass') do
+    klass_b.randomize
+  end
+
+  x.report('LM.mixin') do
+    klass_c.randomize
+  end
+
+  x.report('LM.alias') do
+    klass_d.randomize
+  end
+
+  x.report('Memoist2') do
+    klass_z.randomize
+  end
+
+  x.compare!
+end

data/benchmarks/memoit.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require 'memoit'
+require_relative 'base'
+
+class MemoitCache
+
+  memoize def randomize
+    rand(1..99)
+  end
+
+end
+
+klass_a = LiteMemoizeInstanceCache.new
+klass_b = LiteMemoizeKlassCache.new
+klass_c = LiteMemoizeMixinCache.new
+klass_d = LiteMemoizeAliasCache.new
+klass_z = MemoitCache.new
+
+Benchmark.ips do |x|
+  x.report('LM.instance') do
+    klass_a.randomize
+  end
+
+  x.report('LM.klass') do
+    klass_b.randomize
+  end
+
+  x.report('LM.mixin') do
+    klass_c.randomize
+  end
+
+  x.report('LM.alias') do
+    klass_d.randomize
+  end
+
+  x.report('Memoit') do
+    klass_z.randomize
+  end
+
+  x.compare!
+end

data/benchmarks/memoizable.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'memoizable'
+require_relative 'base'
+
+class MemoizableCache
+
+  include Memoizable
+
+  def randomize
+    rand(1..99)
+  end
+
+  memoize :randomize
+
+end
+
+klass_a = LiteMemoizeInstanceCache.new
+klass_b = LiteMemoizeKlassCache.new
+klass_c = LiteMemoizeMixinCache.new
+klass_d = LiteMemoizeAliasCache.new
+klass_z = MemoizableCache.new
+
+Benchmark.ips do |x|
+  x.report('LM.instance') do
+    klass_a.randomize
+  end
+
+  x.report('LM.klass') do
+    klass_b.randomize
+  end
+
+  x.report('LM.mixin') do
+    klass_c.randomize
+  end
+
+  x.report('LM.alias') do
+    klass_d.randomize
+  end
+
+  x.report('Memoizable') do
+    klass_z.randomize
+  end
+
+  x.compare!
+end

data/benchmarks/memoizer.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'memoizer'
+require_relative 'base'
+
+class MemoizerCache
+
+  include Memoizer
+
+  def randomize
+    rand(1..99)
+  end
+
+  memoize :randomize
+
+end
+
+klass_a = LiteMemoizeInstanceCache.new
+klass_b = LiteMemoizeKlassCache.new
+klass_c = LiteMemoizeMixinCache.new
+klass_d = LiteMemoizeAliasCache.new
+klass_z = MemoizerCache.new
+
+Benchmark.ips do |x|
+  x.report('LM.instance') do
+    klass_a.randomize
+  end
+
+  x.report('LM.klass') do
+    klass_b.randomize
+  end
+
+  x.report('LM.mixin') do
+    klass_c.randomize
+  end
+
+  x.report('LM.alias') do
+    klass_d.randomize
+  end
+
+  x.report('Memoizer') do
+    klass_z.randomize
+  end
+
+  x.compare!
+end

data/lib/lite/memoize.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
-%w[version shared klass instance].each do |name|
+%w[version alias mixin instance klass].each do |name|
   require "lite/memoize/#{name}"
 end

data/lib/lite/memoize/alias.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module Lite
+  module Memoize
+    module Alias
+
+      MemoizedMethod = Struct.new(:memoized_method, :ivar, :arity)
+
+      module InstanceMethods
+
+        def memoized_structs(names)
+          ref_obj = self.class.respond_to?(:class_eval) ? singleton_class : self
+          structs = ref_obj.all_memoized_structs
+          return structs if names.empty?
+
+          structs.select { |s| names.include?(s.memoized_method) }
+        end
+
+        def memoize_all(*method_names)
+          memoized_structs(method_names).each do |struct|
+            if struct.arity.zero?
+              __send__(struct.memoized_method)
+            else
+              instance_variable_set(struct.ivar, {})
+            end
+          end
+        end
+
+        def clear_cache(*method_names)
+          memoized_structs(method_names).each do |struct|
+            next unless instance_variable_defined?(struct.ivar)
+
+            remove_instance_variable(struct.ivar)
+          end
+        end
+
+        alias flush_cache clear_cache
+
+      end
+
+      class << self
+
+        # rubocop:disable Lint/NestedMethodDefinition
+        def extended(extender)
+          Lite::Memoize::Alias.memoist_eval(extender) do
+            return if singleton_class.method_defined?(:memoized_methods)
+
+            def self.memoized_methods
+              @_memoized_methods ||= []
+            end
+          end
+        end
+        # rubocop:enable Lint/NestedMethodDefinition
+
+        def memoized_ivar_for(method_name, as = nil)
+          "@#{memoized_prefix(as)}_#{escape_punctuation(method_name)}"
+        end
+
+        def unmemoized_method_for(method_name, as = nil)
+          "#{unmemoized_prefix(as)}_#{method_name}".to_sym
+        end
+
+        def memoized_prefix(as = nil)
+          return '_memoized' unless as
+
+          "_memoized_#{as}"
+        end
+
+        def unmemoized_prefix(as = nil)
+          return '_unmemoized' unless as
+
+          "_unmemoized_#{as}"
+        end
+
+        def escape_punctuation(string)
+          string = string.is_a?(String) ? string.dup : string.to_s
+          return string unless string.end_with?('?', '!')
+
+          string.sub!(/\?\Z/, '_query') || string.sub!(/!\Z/, '_bang') || string
+        end
+
+        def memoist_eval(klass, *args, &block)
+          return klass.class_eval(*args, &block) if klass.respond_to?(:class_eval)
+
+          klass.singleton_class.class_eval(*args, &block)
+        end
+
+      end
+
+      def all_memoized_structs
+        @all_memoized_structs ||= begin
+          structs = memoized_methods.dup
+
+          ancestors.grep(Lite::Memoize::Alias).each do |ancestor|
+            ancestor.memoized_methods.each do |m|
+              next if structs.any? { |am| am.memoized_method == m.memoized_method }
+
+              structs << m
+            end
+          end
+
+          structs
+        end
+      end
+
+      def clear_structs
+        @all_memoized_structs = nil
+      end
+
+      # rubocop:disable Metrics/AbcSize, Metrics/BlockLength, Metrics/CyclomaticComplexity
+      # rubocop:disable Metrics/MethodLength, Metrics/PerceivedComplexity
+      def memoize(*method_names)
+        as = method_names.pop[:as] if method_names.last.is_a?(Hash)
+
+        method_names.each do |method_name|
+          unmemoized_method = Lite::Memoize::Alias.unmemoized_method_for(method_name, as)
+          memoized_ivar = Lite::Memoize::Alias.memoized_ivar_for(method_name, as)
+
+          Lite::Memoize::Alias.memoist_eval(self) do
+            include InstanceMethods
+
+            # rubocop:disable Lint/NonLocalExitFromIterator
+            if method_defined?(unmemoized_method)
+              warn "Already memoized #{method_name}"
+              return
+            end
+            # rubocop:enable Lint/NonLocalExitFromIterator
+
+            alias_method unmemoized_method, method_name
+
+            mm = MemoizedMethod.new(method_name, memoized_ivar, instance_method(method_name).arity)
+            memoized_methods << mm
+
+            if mm.arity.zero?
+              module_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def #{method_name}(reload: false)
+                  skip_cache = reload || !instance_variable_defined?("#{memoized_ivar}")
+                  set_cache = skip_cache && !frozen?
+
+                  if skip_cache
+                    value = #{unmemoized_method}
+                  else
+                    value = #{memoized_ivar}
+                  end
+
+                  if set_cache
+                    #{memoized_ivar} = value
+                  end
+
+                  value
+                end
+              RUBY
+            else
+              module_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def #{method_name}(*args, reload: false)
+                  skip_cache = reload || !(instance_variable_defined?(#{memoized_ivar.inspect}) && #{memoized_ivar} && #{memoized_ivar}.key?(args))
+                  set_cache = skip_cache && !frozen?
+
+                  if skip_cache
+                    value = #{unmemoized_method}(*args)
+                  else
+                    value = #{memoized_ivar}[args]
+                  end
+
+                  if set_cache
+                    #{memoized_ivar} ||= {}
+                    #{memoized_ivar}[args] = value
+                  end
+
+                  value
+                end
+              RUBY
+            end
+
+            if private_method_defined?(unmemoized_method)
+              private method_name
+            elsif protected_method_defined?(unmemoized_method)
+              protected method_name
+            end
+          end
+        end
+
+        method_names.size == 1 ? method_names.first : method_names
+      end
+      # rubocop:enable Metrics/MethodLength, Metrics/PerceivedComplexity
+      # rubocop:enable Metrics/AbcSize, Metrics/BlockLength, Metrics/CyclomaticComplexity
+
+    end
+  end
+end

data/lib/lite/memoize/instance.rb

@@ -4,59 +4,62 @@ module Lite
   module Memoize
     class Instance
 
-      include Lite::Memoize::Shared
-
-      CALLER_METHOD_REGEX ||= /`([^']*)'/.freeze
+      include Lite::Memoize::Mixin
 
       def initialize; end
 
       def [](key)
-        cache[key]
+        store[key]
       end
 
       def []=(key, val)
-        cache[key] = val
+        store[key] = val
       end
 
       def clear
-        cache.clear
+        store.clear
       end
 
+      alias flush clear
+
       def delete(key)
-        cache.delete(key)
+        store.delete(key)
       end
 
       # :nocov:
       def each
-        cache.each { |key, val| yield(key, val) }
+        store.each { |key, val| yield(key, val) }
       end
       # :nocov:
 
       def empty?
-        cache.empty?
+        store.empty?
       end
 
       alias blank? empty?
 
       def key?(key)
-        cache.key?(key)
+        store.key?(key)
       end
 
       alias hit? key?
 
       def keys
-        cache.keys
+        store.keys
       end
 
       def merge!(hash)
-        cache.merge!(hash)
+        store.merge!(hash)
       end
 
-      def memoize(as: nil, refresh: false, &block)
-        key = key(as || caller_method, caller_locals(block))
-        return cache[key] if !refresh && cache.key?(key)
+      def memoize(as: nil, args: nil, reload: false, &block)
+        key = caller_key(args || block, as: as)
 
-        cache[key] = yield(block)
+        if reload
+          store[key] = yield
+        else
+          store[key] ||= yield
+        end
       end
 
       def present?
@@ -66,37 +69,23 @@ module Lite
       alias hits? present?
 
       def size
-        cache.size
+        store.size
       end
 
       def slice!(*keys)
-        keys.each { |key| cache.delete(key) }
-        cache
+        keys.each { |key| store.delete(key) }
+        store
       end
 
       def to_hash
-        cache
+        store
       end
 
       alias as_json to_hash
       alias hits to_hash
 
       def values
-        cache.values
-      end
-
-      private
-
-      def caller_locals(block)
-        local_vars = block.binding.local_variables
-        local_vars.flat_map { |name| [name, block.binding.local_variable_get(name)] }
-      end
-
-      def caller_method
-        val = caller(2..2).first[CALLER_METHOD_REGEX, 1]
-        return val unless val.include?('<top (required)>')
-
-        caller(1..1).first[CALLER_METHOD_REGEX, 1]
+        store.values
       end
 
     end

data/lib/lite/memoize/klass.rb

@@ -4,14 +4,15 @@ module Lite
   module Memoize
     module Klass
 
-      include Lite::Memoize::Shared
+      include Lite::Memoize::Mixin
 
       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)
+          key = self.class.caller_key(args, as: as || method_name)
+
+          self.class.store[key] ||= inner_method.bind(self).call(*args)
         end
       end
 

data/lib/lite/memoize/mixin.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Lite
+  module Memoize
+    module Mixin
+
+      def store
+        @_memoized_methods ||= {}
+      end
+
+      def caller_key(block, as: nil)
+        name = as ? [as] : block.source_location
+        return name.concat(block) if block.is_a?(Array)
+
+        block.binding.local_variables.each_with_object(name) do |local_name, array|
+          array << local_name
+          array << block.binding.local_variable_get(local_name)
+        end
+      end
+
+      def memoize(method_name, args: nil, reload: false)
+        key = "#{method_name}:#{args}"
+
+        if reload
+          store[key] = yield
+        else
+          store[key] ||= yield
+        end
+      end
+
+    end
+  end
+end

data/lib/lite/memoize/version.rb

@@ -3,7 +3,7 @@
 module Lite
   module Memoize
 
-    VERSION ||= '1.0.0'
+    VERSION ||= '1.0.1'
 
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lite-memoize
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - Juan Gomez
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2019-06-24 00:00:00.000000000 Z
+date: 2019-07-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -128,12 +128,22 @@ files:
 - README.md
 - Rakefile
 - _config.yml
+- benchmarks/base.rb
+- benchmarks/memery.rb
+- benchmarks/memist.rb
+- benchmarks/memo-it.rb
+- benchmarks/memoist.rb
+- benchmarks/memoist2.rb
+- benchmarks/memoit.rb
+- benchmarks/memoizable.rb
+- benchmarks/memoizer.rb
 - bin/console
 - bin/setup
 - lib/lite/memoize.rb
+- lib/lite/memoize/alias.rb
 - lib/lite/memoize/instance.rb
 - lib/lite/memoize/klass.rb
-- lib/lite/memoize/shared.rb
+- lib/lite/memoize/mixin.rb
 - lib/lite/memoize/version.rb
 - lite-memoize.gemspec
 homepage: http://drexed.github.io/lite-memoize

data/lib/lite/memoize/shared.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require 'digest'
-
-module Lite
-  module Memoize
-    module Shared
-
-      def cache
-        @cache ||= {}
-      end
-
-      def key(method_name, method_args)
-        return method_name.to_s if method_args.empty?
-
-        method_sha1 = Digest::SHA1.hexdigest(method_args.to_s)
-        "#{method_name}:#{method_sha1}"
-      end
-
-    end
-  end
-end