cache-machine 0.1.10 → 0.2.0

data/lib/cache_machine/cache/mapper.rb

@@ -0,0 +1,135 @@
+module CacheMachine
+  module Cache
+    require 'cache_machine/cache/collection'
+    require 'cache_machine/cache/resource'
+    require 'cache_machine/cache/class_timestamp'
+
+    # CacheMachine::Cache::Map.draw do
+    #   resource Venue, :timestamp => false do                          # Says what Venue class should be used as a source of ids for map
+    #     collection :events, :scopes => :active, :on => :after_save do  # Says what every event should fill the map with venue ids and use callback to reset cache for every venue.
+    #       member :upcoming_events                                     # Says what this method also needs to be reset.
+    #       members :similar_events, :festivals
+    #     end
+    #   end
+    #
+    #   resource Event # Says what Event class should use timestamp on update (same as resource Event :timestamp => true)
+    # end
+
+    class Mapper
+      DEFAULT_RESOURCE_OPTIONS   = { :timestamp => true,        :scopes => :scoped }
+      DEFAULT_COLLECTION_OPTIONS = { :on        => :after_save, :scopes => :scoped }
+
+      attr_reader :cache_resource
+      attr_reader :scope
+
+      def initialize(&block)
+        change_scope! nil, :root
+        instance_eval(&block) if block_given?
+      end
+
+      # Defines model as a source of ids for map.
+      #
+      # @param [Class] model
+      # @param [Hash]options
+      def resource(model, options = {}, &block)
+        scoped :root, :resource do
+          @cache_resource = model
+
+          unless @cache_resource.include? CacheMachine::Cache::Resource
+            @cache_resource.send :include, CacheMachine::Cache::Resource
+          end
+
+          options.reverse_merge! DEFAULT_RESOURCE_OPTIONS
+
+          # Scopes are used for filtering records what we do not want to store in cache-map.
+          @cache_resource.cache_scopes |= [*options[:scopes]]
+
+          # Timestamp is used for tracking changes in whole collection (outside any scope).
+          if options[:timestamp]
+            unless @cache_resource.include? CacheMachine::Cache::ClassTimestamp
+              @cache_resource.send(:include, CacheMachine::Cache::ClassTimestamp)
+            end
+          end
+
+          # Hook on associated collections.
+          instance_eval(&block) if block_given?
+
+          # Register model as a cache-resource.
+          CacheMachine::Cache::Map.registered_models |= [@cache_resource]
+        end
+      end
+
+      protected
+
+        # Adds callbacks to fill the map with model ids and uses callback to reset cache for every instance of the model.
+        #
+        # @param [String, Symbol] collection_name
+        # @param [Hash] options
+        def collection(collection_name, options = {}, &block)
+          reflection = @cache_resource.reflect_on_association(collection_name)
+          reflection or raise ArgumentError, "Relation '#{collection_name}' is not set on the class #{@cache_resource}"
+
+          scoped :resource, :collection do
+            options.reverse_merge! DEFAULT_COLLECTION_OPTIONS
+
+            collection_klass   = reflection.klass
+            collection_members = get_members(&block)
+
+            unless collection_klass.include? CacheMachine::Cache::Collection
+              collection_klass.send :include, CacheMachine::Cache::Collection
+            end
+
+            collection_klass.register_cache_dependency @cache_resource, collection_name, { :scopes  => options[:scopes],
+                                                                                           :members => collection_members,
+                                                                                           :on      => options[:on] }
+            @cache_resource.cached_collections |= [collection_name]
+          end
+        end
+
+        # Appends member to the collection.
+        #
+        # @param [Array<String, Symbol>] member_names
+        def member(*member_names)
+          scoped :collection, :member do
+            @members = (@members || []) | member_names
+          end
+        end
+        alias members member
+
+        # Returns members of collection in scope.
+        #
+        # @return [Hash]
+        def get_members(&block)
+          @members = []
+          instance_eval(&block) if block_given?
+          @members
+        end
+
+        # Checks if method can be called from the scope.
+        #
+        # @param [Symbol] scope
+        def validate_scope!(scope)
+          raise "#{scope} can not be called in #{@scope} scope" if @scope != scope
+        end
+
+        # Changes scope from one to another.
+        #
+        # @param [Symbol] from
+        # @param [Symbol] to
+        def change_scope!(from, to)
+          validate_scope!(from)
+          @scope = to
+        end
+
+        # Runs code in the given scope.
+        #
+        # @param [Symbol] from
+        # @param [Symbol] to
+        def scoped(from, to)
+          change_scope! from, to
+          yield
+          change_scope! to, from
+        end
+    end
+  end
+end

data/lib/cache_machine/cache/resource.rb

@@ -0,0 +1,108 @@
+module CacheMachine
+  module Cache
+    module Resource
+      extend ActiveSupport::Concern
+
+      included do
+        CacheMachine::Logger.info "CACHE_MACHINE: bind cache-map on class #{self.name}"
+
+        include CacheMachine::Cache::Associations
+        include CacheMachine::Cache::Scope
+
+        cattr_accessor :cached_collections
+        self.cached_collections = []
+
+        # Returns cache key of the member.
+        #
+        # @param [ String, Symbol ] member
+        #
+        # @return [ String ]
+        def cache_key_of(member)
+          CacheMachine::Cache::Map.resource_cache_key(self.class, self.send(self.class.primary_key), member)
+        end
+
+        # Fetches cache of the member.
+        #
+        # @example Fetch cache of associated collection to be refreshed every hour.
+        #   @instance.fetch_cache_of :association, :timestamp => lambda { custom_instance_method },
+        #                                          :expires_in => 1.hour
+        #
+        # @param [ Symbol ] _member
+        # @param [ Hash ] options
+        #
+        # @return [ * ]
+        def fetch_cache_of(_member, options = {}, &block)
+          expires_in = if expires_at = options[:expires_at]
+            expires_at = expires_at.call if expires_at.kind_of? Proc
+
+            if expires_at.is_a? Date
+              expires_at = expires_at.to_time
+            end
+
+            if expires_at.kind_of? DateTime
+              expires_at - DateTime.now
+            else
+              raise ArgumentError, "expires_at is not a Date or DateTime"
+            end
+          else
+            options[:expires_in]
+          end
+
+          if expires_in && expires_in < 0
+            yield
+          else
+            if options.has_key? :timestamp
+              unless self.class.respond_to? options[:timestamp]
+                raise ArgumentError, "Undefined timestamp '#{options[:timestamp]}' for class #{self.class}"
+              end
+
+              _member = CacheMachine::Cache::Map.timestamped_resource_member_key(self.class,
+                                                                                 self.send(self.class.primary_key),
+                                                                                 _member,
+                                                                                 self.class.send(options[:timestamp]))
+            end
+            CacheMachine::Logger.info "CACHE_MACHINE (fetch_cache_of): reading '#{cache_key_of(_member)}'."
+            CacheMachine::Cache::storage_adapter.fetch(cache_key_of(_member), :expires_in => expires_in, &block)
+          end
+        end
+        alias fetch_cache fetch_cache_of
+
+        # Removes all caches using map.
+        def delete_all_caches
+          self.class.cached_collections.each &method(:delete_cache_of)
+        end
+        alias reset_all_caches delete_all_caches
+
+        # Recursively deletes cache by map starting from the member.
+        #
+        # @param [ Symbol ] member
+        def delete_cache_of(member)
+          reflection = self.class.reflect_on_association(member)
+
+          if reflection
+            reflection.klass.reset_resource_cache(self, member)
+          else
+            delete_cache_of_only member
+          end
+        end
+        alias delete_cache delete_cache_of
+
+        # Deletes cache of the only member ignoring cache map.
+        #
+        # @param [ Symbol ] member
+        def delete_cache_of_only(member)
+          CacheMachine::Cache::Map.reset_cache_on_map(self.class, self.send(self.class.primary_key), member)
+        end
+        alias delete_member_cache delete_cache_of_only
+
+        # Deletes cache of anything from memory.
+        #
+        # @param [ String, Symbol ] anything
+        def reset_timestamp_of(anything)
+          CacheMachine::Cache::Map.reset_resource_timestamp(self.class, self.send(self.class.primary_key), anything)
+        end
+        alias reset_timestamp reset_timestamp_of
+      end
+    end
+  end
+end

data/lib/cache_machine/cache/scope.rb

@@ -0,0 +1,24 @@
+module CacheMachine
+  module Cache
+    module Scope
+      extend ActiveSupport::Concern
+
+      included do
+        cattr_accessor :cache_scopes
+        self.cache_scopes = []
+      end
+
+      module ClassMethods
+
+        # Returns scope used for cache-map defined for this class.
+        #
+        # @return [ ActiveRecord::Relation ]
+        def under_cache_scopes
+          result = self.scoped
+          [*self.cache_scopes].each { |scope| result = result.send(scope) }
+          result
+        end
+      end
+    end
+  end
+end

data/lib/cache_machine/cache/timestamp_builder.rb

@@ -0,0 +1,58 @@
+module CacheMachine
+  module Cache
+    module TimestampBuilder
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+
+        # Defines timestamp for object.
+        #
+        # @example Define timestamp to be updated every hour.
+        #   class MyModel < ActiveRecord::Base
+        #     define_timestamp(:my_timestamp, :expires_in => 1.hour) { [ Date.today.to_s, self.last.updated_at ] }
+        #   end
+        #
+        # @param [ String, Symbol ] timestamp_name
+        # @param [ Hash ] options
+        def define_timestamp(timestamp_name, options = {}, &block)
+          (class << self; self end).send(:define_method, timestamp_name) do
+
+            # Block affecting on timestamp.
+            stamp_value = block_given? ? ([*instance_eval(&block)] << 'stamp').join('_') : 'stamp'
+
+            # The key of timestamp itself.
+            stamp_key_value = timestamp_key_of("#{timestamp_name}_#{stamp_value}")
+
+            # The key of the key of timestamp.
+            stamp_key = timestamp_key_of(timestamp_name)
+
+            # The key of timestamp from the cache (previous value).
+            cached_stamp_key_value = CacheMachine::Cache::timestamps_adapter.fetch_timestamp(stamp_key) { stamp_key_value }
+
+            # Timestamp is updated. Delete old key from cache to do not pollute it with dead-keys.
+            if stamp_key_value != cached_stamp_key_value
+              CacheMachine::Cache::timestamps_adapter.reset_timestamp(stamp_key)
+              CacheMachine::Cache::timestamps_adapter.reset_timestamp(cached_stamp_key_value)
+            end
+
+            CacheMachine::Cache::timestamps_adapter.fetch_timestamp(stamp_key_value, options) do
+              Time.now.to_i.to_s
+            end
+          end
+        end
+
+        # Returns timestamp cache key for anything.
+        #
+        # @param [ String, Symbol ] anything
+        #
+        # @return [ String ]
+        def timestamp_key_of(anything)
+          "#{self.name}~#{anything}~ts"
+        end
+        alias timestamp_key timestamp_key_of
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.send :include, CacheMachine::Cache::TimestampBuilder

data/lib/cache_machine/helpers/cache_helper.rb

@@ -2,7 +2,7 @@ module CacheMachine
   module Helpers
     module CacheHelper
 
-      # Returns cached EHTML content.
+      # Returns cached content for your views.
       #
       # @example Return html from cache.
       #   = cache_for @instance, :association do
@@ -13,8 +13,8 @@ module CacheMachine
       # @param [ Hash ] options
       #
       # @return [ String ]
-      def cache_for record, cacheable, options = {}, &block
-        record.fetch_cache_of(cacheable, options.merge(:format => :ehtml)) { capture &block }
+      def cache_for(record, cacheable, options = {}, &block)
+        record.fetch_cache_of(cacheable, options) { capture &block }
       end
     end
   end

data/lib/cache_machine/logger.rb

@@ -8,7 +8,10 @@ module CacheMachine
                        :none   => 10 } # No output at all.
 
     # The default log level.
-    @@level = LOGGING_LEVELS[:none]
+    cattr_accessor :level
+    cattr_accessor :logger
+
+    self.level = LOGGING_LEVELS[:none]
 
     class << self
       LOGGING_LEVELS.keys.each do |level|
@@ -21,20 +24,18 @@ module CacheMachine
       #   ActiveRecord::CacheMachine::Logger.level = :info
       #
       # @param [Symbol] value
-      def level= value
+      def level=(value)
         @@level = LOGGING_LEVELS[value] or raise "CACHE_MACHINE: Unknown log level: '#{value}'."
-        if @@level <= LOGGING_LEVELS[:info]
-          puts "CACHE_MACHINE: Setting log level to '#{value}'.\n"
-        end
+        puts "CACHE_MACHINE: Setting log level to '#{value}'."
       end
 
       # Logs the given entry with the given log level.
       #
       # @param [ Symbol ] level
       # @param [ String ] text
-      def write level, text
-        if @@level <= (LOGGING_LEVELS[level] or raise "CACHE_MACHINE: Unknown log level: '#{level}'.")
-          puts text
+      def write(level, text)
+        if self.level <= LOGGING_LEVELS[level]
+          self.logger ? self.logger.info(text) : puts(text)
         end
       end
     end

data/lib/cache_machine/railtie.rb

@@ -5,5 +5,16 @@ module CacheMachine
         include CacheMachine::Helpers::CacheHelper
       end
     end
+
+    config.after_initialize do
+
+      CacheMachine::Cache::Map.registered_maps.each do |block|
+        CacheMachine::Cache::Mapper.new.instance_eval(&block)
+      end
+    end
+
+    rake_tasks do
+      load 'cache_machine/tasks.rb'
+    end
   end
 end

data/lib/cache_machine/tasks.rb

@@ -0,0 +1,10 @@
+namespace :cache_machine do
+  desc "Caches the map of associations."
+  task :fill_associations_map, [:models] => :environment do |t, args|
+    models = args[:models] ? args[:models].map(&:constantize) : CacheMachine::Cache::Map.registered_models
+    models.each do |model|
+      puts "Processing #{model}..."
+      CacheMachine::Cache::Map.fill_associations_map model
+    end
+  end
+end

data/spec/fixtures.rb

@@ -50,6 +50,8 @@ end
 class Join < ActiveRecord::Base
   set_table_name HMT_JOINS_TABLE_NAME
 
+  scope :test_scope, joins(:cacher).where(:cachers => { :name => %w{one two} })
+
   belongs_to :cacher, :class_name => 'Cacher'
   belongs_to :has_many_through_cacheable, :class_name => 'HasManyThroughCacheable'
 end
@@ -65,15 +67,18 @@ class Polymorphic < ActiveRecord::Base
 end
 
 class Cacher < ActiveRecord::Base
+  cattr_accessor :stamp
   set_table_name TARGET_TABLE_NAME
 
-  cache_map :polymorphics,
-            :child_cachers,
-            :has_many_cacheables => :dependent_cache,
-            :has_many_through_cacheables => :dependent_cache,
-            :has_and_belongs_to_many_cacheables => :dependent_cache
+  define_timestamp :resource_test_timestamp do
+    self.stamp
+  end
+
+  define_timestamp :resource_test_timestamp2 do
+    [self.stamp, 2]
+  end
 
-  define_timestamp(:dynamic_timestamp) { execute_timestamp }
+  scope :test_scope, where(:name => %w{one two})
 
   has_and_belongs_to_many :has_and_belongs_to_many_cacheables, :class_name => 'HasAndBelongsToManyCacheable'
   has_many :has_many_cacheables, :class_name => 'HasManyCacheable'