cache_keeper 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a594d57869401830f847424c24851913039af6979f2e5f9665d77b96bb2c955e
-  data.tar.gz: c80f3edb0b84157a3e49ef8438347931c515ecffe2a55c9a08a630b2fca1c6c0
+  metadata.gz: c67412b5f220a3adf468e0dbb26e7ebe170e2585806e5b1573f8ebba0c9e464f
+  data.tar.gz: 86ae3889c37ab555a6c7fd517cc6782de5cc3d3b11c793491f81a97f23a2b3ac
 SHA512:
-  metadata.gz: 46806eb4e857047be29c784b9c8455a2ce92ac79ebe19fac9bcec704fa9c29c48b63ebf546e78d615cf8d429044bc7557dbac7e94abc939b1288353f856729b3
-  data.tar.gz: b1902aa78ec63d686c7435924c412c997828c117cc498a6a474d0b00c3175c621542d5677a74bb97172523d0a24df38ee916ab8c0a0edafc42047a31dfa87a21
+  metadata.gz: d500ec9f67aaa5d61d3ffed9246ca9ac30fe08a76130b9687ae015859f22af5ac27881c95794310428f315e23d870f59e42d4fbd433f3c66ae2d469dd0480577
+  data.tar.gz: 1468c273f8f91f0761d9bc0b0ca31641732a3d424da4a85c247e776ff8eb68d5a9c162a02be3cff51f832cf55ac3d35b6ecf5193220c9f1174faff26e62affab

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    cache_keeper (0.1.0)
+    cache_keeper (0.1.1)
       rails (>= 6.1.0)
 
 GEM

data/lib/cache_keeper/caching.rb

@@ -1,20 +1,22 @@
-module CacheKeeper::Caching
-  extend ActiveSupport::Concern
+module CacheKeeper
+  module Caching
+    extend ActiveSupport::Concern
 
-  included do
-    def self.caches(*method_names, **options)
-      method_names.each do |method_name|
-        CacheKeeper.manager.handle self, method_name, options
+    included do
+      def self.caches(*method_names, **options)
+        method_names.each do |method_name|
+          CacheKeeper.manager.handle self, method_name, options
 
-        # If the method is already defined, we need to hook it
-        method_added method_name
+          # If the method is already defined, we need to hook it
+          method_added method_name
+        end
       end
-    end
 
-    def self.method_added(method_name)
-      super
+      def self.method_added(method_name)
+        super
 
-      CacheKeeper.manager.activate_if_handling self, method_name
+        CacheKeeper.manager.activate_if_handling self, method_name
+      end
     end
   end
 end

data/lib/cache_keeper/configuration.rb

@@ -1,20 +1,22 @@
-class CacheKeeper::Configuration
-  DEFAULT_MUST_REVALIDATE = false
-  DEFAULT_QUEUES = {}
+module CacheKeeper
+  class Configuration
+    DEFAULT_MUST_REVALIDATE = false
+    DEFAULT_QUEUES = {}
 
-  def must_revalidate
-    return rails_config[:must_revalidate] unless rails_config[:must_revalidate].nil?
+    def must_revalidate
+      return rails_config[:must_revalidate] unless rails_config[:must_revalidate].nil?
 
-    DEFAULT_MUST_REVALIDATE
-  end
+      DEFAULT_MUST_REVALIDATE
+    end
 
-  def queues
-    rails_config[:queues] || DEFAULT_QUEUES
-  end
+    def queues
+      rails_config[:queues] || DEFAULT_QUEUES
+    end
 
-  private
+    private
 
-  def rails_config
-    Rails.application.config.cache_keeper
+    def rails_config
+      Rails.application.config.cache_keeper
+    end
   end
 end

data/lib/cache_keeper/engine.rb

@@ -1,22 +1,31 @@
-class CacheKeeper::Engine < ::Rails::Engine
-  isolate_namespace CacheKeeper
+module CacheKeeper
+  class Engine < ::Rails::Engine
+    isolate_namespace CacheKeeper
 
-  config.cache_keeper = ActiveSupport::OrderedOptions.new
-  config.cache_keeper.queues = ActiveSupport::InheritableOptions.new
+    config.cache_keeper = ActiveSupport::OrderedOptions.new
+    config.cache_keeper.queues = ActiveSupport::InheritableOptions.new
 
-  initializer "cache_keeper.active_job_serializer" do |app|
-    config.to_prepare do
-      Rails.application.config.active_job.custom_serializers << CacheKeeper::CachedMethodSerializer
-    end
-  end
+    config.eager_load_namespaces << CacheKeeper
+    config.autoload_once_paths = %W(
+      #{root}/app/jobs
+      #{root}/app/models
+      #{root}/app/serializers
+    )
 
-  initializer "cache_keeper.caching_methods" do |app|
-    ActiveSupport.on_load :action_controller do
-      ActionController::Base.send :include, CacheKeeper::Caching
+    initializer "cache_keeper.active_job_serializer" do |app|
+      config.to_prepare do
+        Rails.application.config.active_job.custom_serializers << CacheKeeper::CachedMethodSerializer
+      end
     end
 
-    ActiveSupport.on_load :active_record do
-      include CacheKeeper::Caching
+    initializer "cache_keeper.caching_methods" do |app|
+      ActiveSupport.on_load :action_controller do
+        ActionController::Base.send :include, CacheKeeper::Caching
+      end
+
+      ActiveSupport.on_load :active_record do
+        include CacheKeeper::Caching
+      end
     end
   end
 end

data/lib/cache_keeper/manager.rb

@@ -1,42 +1,44 @@
-class CacheKeeper::Manager
-  attr_accessor :cached_methods
+module CacheKeeper
+  class Manager
+    attr_accessor :cached_methods
 
-  def initialize
-    self.cached_methods = []
-  end
+    def initialize
+      self.cached_methods = []
+    end
 
-  def find(klass, method_name)
-    cached_methods.find do |cached_method|
-      cached_method.klass == klass && cached_method.method_name == method_name
+    def find(klass, method_name)
+      cached_methods.find do |cached_method|
+        cached_method.klass == klass && cached_method.method_name == method_name
+      end
     end
-  end
 
-  def handled?(klass, method_name)
-    find(klass, method_name).present?
-  end
+    def handled?(klass, method_name)
+      find(klass, method_name).present?
+    end
 
-  def handle(klass, method_name, options)
-    CacheKeeper::CachedMethod.new(klass, method_name, options).tap do |cached_method|
-      cached_methods << cached_method
+    def handle(klass, method_name, options)
+      CacheKeeper::CachedMethod.new(klass, method_name, options).tap do |cached_method|
+        cached_methods << cached_method
+      end
     end
-  end
 
-  def activate_if_handling(klass, method_name)
-    cached_method = find(klass, method_name) or return
+    def activate_if_handling(klass, method_name)
+      cached_method = find(klass, method_name) or return
 
-    return unless requires_activation?(cached_method)
+      return unless requires_activation?(cached_method)
 
-    CacheKeeper::ReplaceMethod.replace(cached_method) do
-      cached_method.call(self)
+      CacheKeeper::ReplaceMethod.replace(cached_method) do
+        cached_method.call(self)
+      end
     end
-  end
 
-  private
+    private
 
-  def requires_activation?(cached_method)
-    return false if cached_method.klass.instance_methods.exclude?(cached_method.method_name) && cached_method.klass.private_instance_methods.exclude?(cached_method.method_name)
-    return false if cached_method.klass.private_instance_methods.include?(cached_method.alias_for_original_method)
+    def requires_activation?(cached_method)
+      return false if cached_method.klass.instance_methods.exclude?(cached_method.method_name) && cached_method.klass.private_instance_methods.exclude?(cached_method.method_name)
+      return false if cached_method.klass.private_instance_methods.include?(cached_method.alias_for_original_method)
 
-    true
+      true
+    end
   end
 end

data/lib/cache_keeper/replace_method.rb

@@ -1,46 +1,48 @@
 # Based on https://github.com/Shopify/sorbet/blob/master/gems/sorbet-runtime/lib/types/private/class_utils.rb
-class CacheKeeper::ReplaceMethod
-  class << self
-    def replace(cached_method, &block)
-      klass = cached_method.klass
-      method_name = cached_method.method_name
-      alias_for_original_method = cached_method.alias_for_original_method
-      original_visibility = visibility_method_name(klass, method_name)
+module CacheKeeper
+  class ReplaceMethod
+    class << self
+      def replace(cached_method, &block)
+        klass = cached_method.klass
+        method_name = cached_method.method_name
+        alias_for_original_method = cached_method.alias_for_original_method
+        original_visibility = visibility_method_name(klass, method_name)
 
-      define_method_with_visibility klass, method_name, alias_for_original_method, original_visibility, &block
-    end
+        define_method_with_visibility klass, method_name, alias_for_original_method, original_visibility, &block
+      end
 
-    private
+      private
 
-    # `name` must be an instance method (for class methods, pass in mod.singleton_class)
-    def visibility_method_name(klass, method_name)
-      if klass.public_method_defined? method_name
-        :public
-      elsif klass.protected_method_defined? method_name
-        :protected
-      elsif klass.private_method_defined? method_name
-        :private
-      else
-        raise NameError.new("undefined method `#{method_name}` for `#{klass}`")
+      # `name` must be an instance method (for class methods, pass in mod.singleton_class)
+      def visibility_method_name(klass, method_name)
+        if klass.public_method_defined? method_name
+          :public
+        elsif klass.protected_method_defined? method_name
+          :protected
+        elsif klass.private_method_defined? method_name
+          :private
+        else
+          raise NameError.new("undefined method `#{method_name}` for `#{klass}`")
+        end
       end
-    end
 
-    def define_method_with_visibility(klass, method_name, alias_for_original_method, visibility, &block)
-      klass.module_exec do
-        alias_method alias_for_original_method, method_name
-        private alias_for_original_method
+      def define_method_with_visibility(klass, method_name, alias_for_original_method, visibility, &block)
+        klass.module_exec do
+          alias_method alias_for_original_method, method_name
+          private alias_for_original_method
 
-        # Start a visibility (public/protected/private) region, so that
-        # all of the method redefinitions happen with the right visibility
-        # from the beginning. This ensures that any other code that is
-        # triggered by `method_added`, sees the redefined method with the
-        # right visibility.
-        send visibility
+          # Start a visibility (public/protected/private) region, so that
+          # all of the method redefinitions happen with the right visibility
+          # from the beginning. This ensures that any other code that is
+          # triggered by `method_added`, sees the redefined method with the
+          # right visibility.
+          send visibility
 
-        define_method method_name, &block
+          define_method method_name, &block
 
-        if block && block.arity < 0 && respond_to?(:ruby2_keywords, true)
-          ruby2_keywords method_name
+          if block && block.arity < 0 && respond_to?(:ruby2_keywords, true)
+            ruby2_keywords method_name
+          end
         end
       end
     end

data/lib/cache_keeper/version.rb

@@ -1,3 +1,3 @@
 module CacheKeeper
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/lib/cache_keeper.rb

@@ -1,11 +1,13 @@
 require "cache_keeper/engine"
 
-require "cache_keeper/caching"
-require "cache_keeper/configuration"
-require "cache_keeper/manager"
-require "cache_keeper/replace_method"
-
 module CacheKeeper
+  extend ActiveSupport::Autoload
+
+  autoload :Caching
+  autoload :Configuration
+  autoload :Manager
+  autoload :ReplaceMethod
+
   mattr_accessor :logger, default: ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new($stdout))
 
   mattr_accessor :configuration, default: CacheKeeper::Configuration.new

data/test/manager_test.rb

@@ -2,6 +2,9 @@ require "test_helper"
 
 class CacheKeeper::ManagerTest < ActiveSupport::TestCase
   test "keeps record of the cached methods" do
+    # Load model
+    Recording
+
     assert_equal 1, CacheKeeper.manager.cached_methods.count
     assert_equal :slow_method, CacheKeeper.manager.cached_methods.first.method_name
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cache_keeper
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Martin Zamuner