second_level_cache 2.1.16 → 2.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: f6149c9f3aaaa26ad9fc6a0fa5633a5602a08c68451eb04c010973e1305649f0
-  data.tar.gz: 1945c39303777ea938b7187a3cad868db17348153fe91bf3844e6d4868201171
+SHA1:
+  metadata.gz: 08afc3105b0fd6181f8c5fa0deeed4c6af159e48
+  data.tar.gz: 591668829c848cd26c9c7ca7ecb7edda0a5378ad
 SHA512:
-  metadata.gz: '09e8ac1d40c06ce9642af57ff1d98a3759490196380caf5093fd203484a2b5f8eda94157d59424227824755778ae4cbeeff75399591576b79411abeee48ba99e'
-  data.tar.gz: 549350c57237148d9b8bb305c8ad6aa7985459111c133bffa4025de02ff61b6380f762b74d619802ad00d09863af0ef596cfdeb2c67b6466c7c50712d8354774
+  metadata.gz: c913f07951f4c923a33580ea6576e03ba4cc30ade72ac4451adaf1b82690e3ffd3f1879ac6fd3f645ea5ec6142b3ec9e52992ecabfb650a89f76e609116cd323
+  data.tar.gz: cbf1edab3ddabb33d5f3a12f234ee29657d232985df41018aaecbcd2aeb614be09536b5e93c6f8ba0fbd16928cadcbaa2d771c7680411ef7e8c904ddf7f2aa3d

data/CHANGELOG.md

@@ -1,13 +1,9 @@
-2.1.15
-* Replace Fixnum class check for Integer class
-
-2.1.14
-* support has_one with scope
+2.2.1
+-----
 
-2.1.10
-* read multi from cache for find(ids)
+* ActiveRecord 5 ready! Do not support ActiveRecord 4 and lower versions now (use second_level_cache 2.1.x).
+* Requirement Ruby 2.3+.
 
------
 2.0.0.rc1
 -----
 * ActiveRecord 4 ready!

data/Gemfile

@@ -2,4 +2,4 @@ source 'https://rubygems.org'
 
 gemspec
 
-gem 'rails', '~> 4.1'
+gem 'rails', '~> 5.0.0.beta2'

data/README.md

@@ -16,6 +16,14 @@ Write-Through: As objects are created, updated, and deleted, all of the caches a
 
 In your gem file:
 
+ActiveRecord 5:
+
+```ruby
+gem 'second_level_cache', '~> 2.2.0'
+```
+
+For ActiveRecord 4:
+
 ```ruby
 gem "second_level_cache", "~> 2.1.9"
 ```
@@ -32,7 +40,7 @@ For example, cache User objects:
 
 ```ruby
 class User < ActiveRecord::Base
-  acts_as_cached(:version => 1, :expires_in => 1.week)
+  acts_as_cached(version: 1, expires_in: 1.week)
 end
 ```
 
@@ -41,14 +49,14 @@ Then it will fetch cached object in this situations:
 ```ruby
 User.find(1)
 user.articles.find(1)
-User.where(:status => 1).find(1)
+User.where(status: 1).find(1)
 article.user
 ```
 
 Cache key:
 
 ```ruby
-user = User.find 1
+user = User.find(1)
 user.second_level_cache_key  # We will get the key looks like "slc/user/1/0"
 ```
 
@@ -67,7 +75,7 @@ Disable SecondLevelCache:
 
 ```ruby
 User.without_second_level_cache do
-  user = User.find 1
+  user = User.find(1)
   # ...
 end
 ```
@@ -111,7 +119,7 @@ DatabaseCleaner.strategy = :truncation
 
 In production env, we recommend to use [Dalli](https://github.com/mperham/dalli) as Rails cache store.
 ```ruby
- config.cache_store = [:dalli_store, APP_CONFIG["memcached_host"], {:namespace => "ns", :compress => true}]
+ config.cache_store = [:dalli_store, APP_CONFIG["memcached_host"], { namespace: "ns", compress: true }]
 ```
 
 ## Tips:
@@ -126,7 +134,7 @@ SecondLevelCache.configure.cache_key_prefix = "slc1"
 
 ```ruby
 class User < ActiveRecord::Base
-  acts_as_cached(:version => 2, :expires_in => 1.week)
+  acts_as_cached(version: 2, expires_in: 1.week)
 end
 ```
 
@@ -141,13 +149,6 @@ post = Post.fetch_by_uniq_keys(user_id: 2, slug: "foo")
 user = User.fetch_by_uniq_keys!(nick_name: "hooopo") # this will raise `ActiveRecord::RecordNotFound` Exception when nick name not exists.
 ```
 
-* multi_read_from_cache
-
-```ruby
-# this will use Rails.cache.multi_read method to fetch record, if miss, then use SQL in query.
-blogs = Blog.multi_read_from_cache([1,2,3])
-```
-
 * You can use Rails's [Eager Loading](http://guides.rubyonrails.org/active_record_querying.html#eager-loading-associations) feature as normal. Even better, second_level_cache will transform the `IN` query into a Rails.cache.multi_read operation. For example:
 
 ```ruby

data/Rakefile

@@ -2,9 +2,9 @@
 require 'bundler/gem_tasks'
 require 'rake/testtask'
 
-task :default => :test
+task default: :test
 
 Rake::TestTask.new do |t|
-  t.libs << "lib" << "test"
+  t.libs << 'lib' << 'test'
   t.test_files = FileList['test/**/*_test.rb']
 end

data/lib/second_level_cache/active_record/base.rb

@@ -1,24 +1,20 @@
-# -*- encoding : utf-8 -*-
 module SecondLevelCache
   module ActiveRecord
     module Base
-      extend ActiveSupport::Concern
+      def self.prepended(base)
+        base.after_commit :expire_second_level_cache, on: :destroy
+        base.after_commit :update_second_level_cache, on: :update
+        base.after_commit :write_second_level_cache, on: :create
 
-      included do
-        after_commit :expire_second_level_cache, :on => :destroy
-        after_commit :update_second_level_cache, :on => :update
-        after_commit :write_second_level_cache, :on => :create
-
-        class << self
-          alias_method_chain :update_counters, :cache
+        class << base
+          prepend ClassMethods
         end
-
       end
 
       module ClassMethods
-        def update_counters_with_cache(id, counters)
-          update_counters_without_cache(id, counters).tap do
-            Array(id).each{|i| expire_second_level_cache(i)}
+        def update_counters(id, counters)
+          super(id, counters).tap do
+            Array(id).each { |i| expire_second_level_cache(i) }
           end
         end
       end

data/lib/second_level_cache/active_record/belongs_to_association.rb

@@ -1,25 +1,21 @@
-# -*- encoding : utf-8 -*-
 module SecondLevelCache
   module ActiveRecord
     module Associations
       module BelongsToAssociation
-        extend ActiveSupport::Concern
-        included do
-          class_eval do
-            alias_method_chain :find_target, :second_level_cache
+        def find_target
+          return super unless klass.second_level_cache_enabled?
+          cache_record = klass.read_second_level_cache(second_level_cache_key)
+          if cache_record
+            return cache_record.tap { |record| set_inverse_instance(record) }
           end
-        end
 
-        def find_target_with_second_level_cache
-          return find_target_without_second_level_cache unless klass.second_level_cache_enabled?
-          cache_record = klass.read_second_level_cache(second_level_cache_key)
-          return cache_record.tap{|record| set_inverse_instance(record)} if cache_record
-          record = find_target_without_second_level_cache
+          record = super
+          return nil unless record
 
           record.tap do |r|
             set_inverse_instance(r)
             r.write_second_level_cache
-          end if record
+          end
         end
 
         private

data/lib/second_level_cache/active_record/core.rb

@@ -1,20 +1,16 @@
-# -*- encoding : utf-8 -*-
 module SecondLevelCache
   module ActiveRecord
     module Core
-      extend ActiveSupport::Concern
-
-      included do
-        class << self
-          alias_method_chain :find, :cache
+      def self.prepended(base)
+        class << base
+          prepend ClassMethods
         end
-
       end
 
       module ClassMethods
-        def find_with_cache(*ids)
-          return all.find(ids.first) if ids.size == 1 && ids.first.is_a?(Integer)
-          find_without_cache(*ids)
+        def find(*ids)
+          return all.find(ids.first) if ids.size == 1 && ids.first.is_a?(Fixnum)
+          super(*ids)
         end
       end
     end

data/lib/second_level_cache/active_record/fetch_by_uniq_key.rb

@@ -1,39 +1,51 @@
-# -*- encoding : utf-8 -*-
 module SecondLevelCache
   module ActiveRecord
     module FetchByUniqKey
       def fetch_by_uniq_keys(where_values)
         cache_key = cache_uniq_key(where_values)
-        if _id = SecondLevelCache.cache_store.read(cache_key)
-          self.find(_id) rescue nil
-        else
-          record = self.where(where_values).first
-          record.tap{|record| SecondLevelCache.cache_store.write(cache_key, record.id)} if record
+        obj_id = SecondLevelCache.cache_store.read(cache_key)
+        if obj_id
+          begin
+            return find(obj_id)
+          rescue
+            return nil
+          end
+        end
+
+        record = where(where_values).first
+        return nil unless record
+
+        record.tap do |r|
+          SecondLevelCache.cache_store.write(cache_key, r.id)
         end
       end
-      
+
       def fetch_by_uniq_keys!(where_values)
-        fetch_by_uniq_keys(where_values) || raise(::ActiveRecord::RecordNotFound)
+        fetch_by_uniq_keys(where_values) || fail(::ActiveRecord::RecordNotFound)
       end
-      
+
       def fetch_by_uniq_key(value, uniq_key_name)
-        # puts "[Deprecated] will remove in the future, use fetch_by_uniq_keys method instead."
+        # puts "[Deprecated] will remove in the future,
+        # use fetch_by_uniq_keys method instead."
         fetch_by_uniq_keys(uniq_key_name => value)
       end
 
       def fetch_by_uniq_key!(value, uniq_key_name)
-        # puts "[Deprecated] will remove in the future, use fetch_by_uniq_keys! method instead."
-        fetch_by_uniq_key(value, uniq_key_name) || raise(::ActiveRecord::RecordNotFound)
+        # puts "[Deprecated] will remove in the future,
+        # use fetch_by_uniq_keys! method instead."
+        fetch_by_uniq_key(value, uniq_key_name) || fail(::ActiveRecord::RecordNotFound)
       end
 
       private
-      
+
       def cache_uniq_key(where_values)
-        ext_key = where_values.collect { |k,v|
+        keys = where_values.collect do |k, v|
           v = Digest::MD5.hexdigest(v) if v && v.size >= 32
-          [k,v].join("_")
-        }.join(",")
-        "uniq_key_#{self.name}_#{ext_key}"
+          [k, v].join('_')
+        end
+
+        ext_key = keys.join(',')
+        "uniq_key_#{name}_#{ext_key}"
       end
     end
   end

data/lib/second_level_cache/active_record/finder_methods.rb

@@ -1,18 +1,12 @@
-# -*- encoding : utf-8 -*-
 module SecondLevelCache
   module ActiveRecord
     module FinderMethods
-      extend ActiveSupport::Concern
-
-      included do
-        alias_method_chain :find_one, :second_level_cache
-        alias_method_chain :find_some, :second_level_cache
-      end
-
+      # TODO: find_some
+      # https://github.com/rails/rails/blob/master/activerecord/lib/active_record/relation/finder_methods.rb#L289-L309
       #
       # Cacheable:
       #
-      #     current_user.articles.where(:status => 1).visiable.find(params[:id])
+      #     current_user.articles.where(status: 1).visiable.find(params[:id])
       #
       # Uncacheable:
       #
@@ -20,60 +14,41 @@ module SecondLevelCache
       #     Article.where("user_id > 1").find(params[:id])
       #     Article.where("articles.user_id = 1").find(prams[:id])
       #     Article.where("user_id = 1 AND ...").find(params[:id])
-      def find_one_with_second_level_cache(id)
-        return find_one_without_second_level_cache(id) unless second_level_cache_enabled?
-        return find_one_without_second_level_cache(id) unless select_all_column?
+      def find_one(id)
+        return super(id) unless second_level_cache_enabled?
+        return super(id) unless select_all_column?
 
-        id = id.id if ActiveRecord::Base === id
+        id = id.id if ActiveRecord::Base == id
 
         if cachable?
           record = @klass.read_second_level_cache(id)
           if record
-            return record if where_values.blank? || where_values_match_cache?(record)
+            if where_values_hash.blank? || where_values_match_cache?(record)
+              return record
+            end
           end
         end
 
-        record = find_one_without_second_level_cache(id)
+        record = super(id)
         record.write_second_level_cache
         record
       end
 
-      def find_some_with_second_level_cache(ids)
-        return find_some_without_second_level_cache(ids) unless second_level_cache_enabled?
-        return find_some_without_second_level_cache(ids) unless select_all_column?
-
-        if cachable?
-          result = multi_read_from_cache(ids)
-        else
-          result = where(:id => ids).all
-        end
+      private
 
-        expected_size =
-          if limit_value && ids.size > limit_value
-            limit_value
-          else
-            ids.size
-          end
-
-        # 11 ids with limit 3, offset 9 should give 2 results.
-        if offset_value && (ids.size - offset_value < expected_size)
-          expected_size = ids.size - offset_value
-        end
-
-        if result.size == expected_size
-          result
-        else
-          raise_record_not_found_exception!(ids, result.size, expected_size)
-        end
+      def cachable?
+        limit_one? &&
+          order_values.blank? &&
+          includes_values.blank? &&
+          preload_values.blank? &&
+          readonly_value.nil? &&
+          joins_values.blank? &&
+          !@klass.locking_enabled? &&
+          where_clause_match_equality?
       end
 
-    private
-
-      def cachable?
-        limit_one? && order_values.blank? &&
-          includes_values.blank? && preload_values.blank? &&
-          readonly_value.nil? && joins_values.blank? && !@klass.locking_enabled? &&
-          where_values.all? { |where_value| where_value.is_a?(::Arel::Nodes::Equality) }
+      def where_clause_match_equality?
+        where_values_hash.all?
       end
 
       def where_values_match_cache?(record)

data/lib/second_level_cache/active_record/has_one_association.rb

@@ -1,35 +1,34 @@
-# -*- encoding : utf-8 -*-
 module SecondLevelCache
   module ActiveRecord
     module Associations
       module HasOneAssociation
-        extend ActiveSupport::Concern
-        included do
-          class_eval do
-            alias_method_chain :find_target, :second_level_cache
-          end
-        end
-
-        def find_target_with_second_level_cache
-          return find_target_without_second_level_cache unless klass.second_level_cache_enabled?
+        def find_target
+          return super unless klass.second_level_cache_enabled?
+          return super if reflection.options[:through] || reflection.scope
+          # TODO: implement cache with has_one through, scope
 
-          return find_target_without_second_level_cache if reflection.options[:through]
-          # TODO: implement cache with has_one through
+          owner_primary_key = owner[reflection.active_record_primary_key]
           if reflection.options[:as]
-            cache_record = klass.fetch_by_uniq_keys({reflection.foreign_key => owner[reflection.active_record_primary_key], reflection.type => owner.class.base_class.name})
-          elsif reflection.scope
-            cache_record = klass.fetch_by_uniq_keys(create_scope)
+            keys = {
+              reflection.foreign_key => owner_primary_key,
+              reflection.type => owner.class.base_class.name
+            }
+            cache_record = klass.fetch_by_uniq_keys(keys)
           else
-            cache_record = klass.fetch_by_uniq_key(owner[reflection.active_record_primary_key], reflection.foreign_key)
+            cache_record = klass.fetch_by_uniq_key(owner_primary_key, reflection.foreign_key)
           end
-          return cache_record.tap{|record| set_inverse_instance(record)} if cache_record
 
-          record = find_target_without_second_level_cache
+          if cache_record
+            return cache_record.tap { |record| set_inverse_instance(record) }
+          end
+
+          record = super
+          return nil unless record
 
           record.tap do |r|
             set_inverse_instance(r)
             r.write_second_level_cache
-          end if record
+          end
         end
       end
     end

data/lib/second_level_cache/active_record/persistence.rb

@@ -1,28 +1,17 @@
-# -*- encoding : utf-8 -*-
 module SecondLevelCache
   module ActiveRecord
     module Persistence
-      extend ActiveSupport::Concern
-
-      included do
-        class_eval do
-          alias_method_chain :reload, :second_level_cache
-          alias_method_chain :touch, :second_level_cache
-          alias_method_chain :update_column, :second_level_cache
-        end
-      end
-
-      def update_column_with_second_level_cache(name, value)
-        update_column_without_second_level_cache(name, value).tap{update_second_level_cache}
+      def update_column(name, value)
+        super(name, value).tap { update_second_level_cache }
       end
 
-      def reload_with_second_level_cache(options = nil)
+      def reload(options = nil)
         expire_second_level_cache
-        reload_without_second_level_cache(options)
+        super(options)
       end
 
-      def touch_with_second_level_cache(*names)
-        touch_without_second_level_cache(*names).tap{update_second_level_cache}
+      def touch(*names)
+        super(*names).tap { update_second_level_cache }
       end
     end
   end

data/lib/second_level_cache/active_record/preloader.rb

@@ -1,34 +1,33 @@
-# -*- encoding : utf-8 -*-
 module SecondLevelCache
   module ActiveRecord
     module Associations
       class Preloader
         module BelongsTo
-          extend ActiveSupport::Concern
+          def records_for(ids)
+            return super(ids) unless klass.second_level_cache_enabled?
 
-          included do
-            alias_method_chain :records_for, :second_level_cache
-          end
-
-          def records_for_with_second_level_cache(ids)
-            return records_for_without_second_level_cache(ids) unless klass.second_level_cache_enabled?
-
-            map_cache_keys = ids.map{|id| klass.second_level_cache_key(id)}
+            map_cache_keys = ids.map { |id| klass.second_level_cache_key(id) }
             records_from_cache = ::SecondLevelCache.cache_store.read_multi(*map_cache_keys)
             # NOTICE
             # Rails.cache.read_multi return hash that has keys only hitted.
             # eg. Rails.cache.read_multi(1,2,3) => {2 => hit_value, 3 => hit_value}
-            hitted_ids = records_from_cache.map{|key, _| key.split("/")[2].to_i}
-            missed_ids = ids.map{|x| x.to_i} - hitted_ids
+            hitted_ids = records_from_cache.map { |key, _| key.split('/')[2].to_i }
+            missed_ids = ids.map(&:to_i) - hitted_ids
+
+            ::SecondLevelCache.logger.info "missed ids -> #{missed_ids.inspect} | hitted ids -> #{hitted_ids.inspect}"
 
-            ::SecondLevelCache::Config.logger.info "missed ids -> #{missed_ids.inspect} | hitted ids -> #{hitted_ids.inspect}"
+            record_marshals = RecordMarshal.load_multi(records_from_cache.values)
 
             if missed_ids.empty?
-              RecordMarshal.load_multi(records_from_cache.values)
-            else
-              records_from_db = records_for_without_second_level_cache(missed_ids)
-              records_from_db.map{|record| write_cache(record); record} + RecordMarshal.load_multi(records_from_cache.values)
+              return record_marshals
             end
+
+            records_from_db = super(missed_ids)
+            records_from_db.map do |r|
+              write_cache(r)
+            end
+
+            records_from_db + record_marshals
           end
 
           private

data/lib/second_level_cache/active_record/railtie.rb

@@ -1,13 +1,16 @@
-class SecondLevelCache::ActiveRecord::Railtie < Rails::Railtie
-  initializer "second_level_cache.active_record.initialization" do
-    ActiveRecord::Base.send(:include, SecondLevelCache::Mixin)
-    ActiveRecord::Base.send(:include, SecondLevelCache::ActiveRecord::Base)
-    ActiveRecord::Base.send(:extend, SecondLevelCache::ActiveRecord::FetchByUniqKey)
-    ActiveRecord::Base.send(:extend, SecondLevelCache::ActiveRecord::MultiReadFromCache)
+module SecondLevelCache
+  module ActiveRecord
+    class Railtie < Rails::Railtie
+      initializer 'second_level_cache.active_record.initialization' do
+        ::ActiveRecord::Base.send(:include, SecondLevelCache::Mixin)
+        ::ActiveRecord::Base.send(:prepend, SecondLevelCache::ActiveRecord::Base)
+        ::ActiveRecord::Base.send(:extend, SecondLevelCache::ActiveRecord::FetchByUniqKey)
 
-    ActiveRecord::Base.send(:include, SecondLevelCache::ActiveRecord::Persistence)
-    ActiveRecord::Associations::BelongsToAssociation.send(:include, SecondLevelCache::ActiveRecord::Associations::BelongsToAssociation)
-    ActiveRecord::Associations::HasOneAssociation.send(:include, SecondLevelCache::ActiveRecord::Associations::HasOneAssociation)
-    ActiveRecord::Associations::Preloader::BelongsTo.send(:include, SecondLevelCache::ActiveRecord::Associations::Preloader::BelongsTo)
+        ::ActiveRecord::Base.send(:prepend, SecondLevelCache::ActiveRecord::Persistence)
+        ::ActiveRecord::Associations::BelongsToAssociation.send(:prepend, SecondLevelCache::ActiveRecord::Associations::BelongsToAssociation)
+        ::ActiveRecord::Associations::HasOneAssociation.send(:prepend, SecondLevelCache::ActiveRecord::Associations::HasOneAssociation)
+        ::ActiveRecord::Associations::Preloader::BelongsTo.send(:prepend, SecondLevelCache::ActiveRecord::Associations::Preloader::BelongsTo)
+      end
+    end
   end
 end

data/lib/second_level_cache/active_record.rb

@@ -1,4 +1,3 @@
-# -*- encoding : utf-8 -*-
 require 'second_level_cache/active_record/base'
 require 'second_level_cache/active_record/core'
 require 'second_level_cache/active_record/fetch_by_uniq_key'
@@ -7,18 +6,16 @@ require 'second_level_cache/active_record/persistence'
 require 'second_level_cache/active_record/belongs_to_association'
 require 'second_level_cache/active_record/has_one_association'
 require 'second_level_cache/active_record/preloader'
-require 'second_level_cache/active_record/multi_read_from_cache'
 
 if defined? Rails
   require 'second_level_cache/active_record/railtie'
 else
   ActiveRecord::Base.send(:include, SecondLevelCache::Mixin)
-  ActiveRecord::Base.send(:include, SecondLevelCache::ActiveRecord::Base)
+  ActiveRecord::Base.send(:prepend, SecondLevelCache::ActiveRecord::Base)
   ActiveRecord::Base.send(:extend, SecondLevelCache::ActiveRecord::FetchByUniqKey)
-  ActiveRecord::Base.send(:extend, SecondLevelCache::ActiveRecord::MultiReadFromCache)
 
-  ActiveRecord::Base.send(:include, SecondLevelCache::ActiveRecord::Persistence)
-  ActiveRecord::Associations::BelongsToAssociation.send(:include, SecondLevelCache::ActiveRecord::Associations::BelongsToAssociation)
-  ActiveRecord::Associations::HasOneAssociation.send(:include, SecondLevelCache::ActiveRecord::Associations::HasOneAssociation)
-  ActiveRecord::Associations::Preloader::BelongsTo.send(:include, SecondLevelCache::ActiveRecord::Associations::Preloader::BelongsTo)
+  ActiveRecord::Base.send(:prepend, SecondLevelCache::ActiveRecord::Persistence)
+  ActiveRecord::Associations::BelongsToAssociation.send(:prepend, SecondLevelCache::ActiveRecord::Associations::BelongsToAssociation)
+  ActiveRecord::Associations::HasOneAssociation.send(:prepend, SecondLevelCache::ActiveRecord::Associations::HasOneAssociation)
+  ActiveRecord::Associations::Preloader::BelongsTo.send(:prepend, SecondLevelCache::ActiveRecord::Associations::Preloader::BelongsTo)
 end

data/lib/second_level_cache/config.rb

@@ -1,22 +1,21 @@
-# -*- encoding : utf-8 -*-
 module SecondLevelCache
-  module Config
-    extend self
+  class Config
+    class << self
+      attr_accessor :cache_store, :logger, :cache_key_prefix
 
-    attr_accessor :cache_store, :logger, :cache_key_prefix
+      def cache_store
+        @cache_store ||= Rails.cache if defined?(Rails)
+        @cache_store
+      end
 
-    def cache_store
-      @cache_store ||= Rails.cache if defined?(Rails)
-      @cache_store
-    end
-
-    def logger
-      @logger ||= Rails.logger if defined?(Rails)
-      @logger ||= Logger.new(STDOUT)
-    end
+      def logger
+        @logger ||= Rails.logger if defined?(Rails)
+        @logger ||= Logger.new(STDOUT)
+      end
 
-    def cache_key_prefix
-      @cache_key_prefix ||= 'slc'
+      def cache_key_prefix
+        @cache_key_prefix ||= 'slc'
+      end
     end
   end
 end