cached_enumeration 2.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+--- 
+SHA1: 
+  metadata.gz: bc6c4ec88760cf1e4287f68b9e5c201842568e40
+  data.tar.gz: b791be8345a7e0dea745bd04e589be8967d5f456
+SHA512: 
+  metadata.gz: ba861a401664cb286f09444df4ef66344eee6de70c9dca6e547c3376c0a4a7cdd6d9e4e0b182cfc6927e366935a231b568cf4ce1ec3eed6cbf4f5c9bf6c700c6
+  data.tar.gz: 5f58d6294394a1e284b20302fc16879660fbe3e9cfa6e1e5014782f4cc636952a9f634f7f3fc92c5c9e2e4c527019bd16bed1d3b8fe716058080a4c1be02287e

data/.gitignore

@@ -0,0 +1,21 @@
+.idea
+.ruby-version
+.ruby-gemset
+.rspec
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.travis.yml

@@ -0,0 +1,15 @@
+language: ruby
+script: "bundle exec rake spec"
+rvm:
+  - 2.0.0
+  - rbx-2.2.10
+  - 2.1.3
+notifications:
+  recipients:
+    - peter.schrammel@experteer.com
+branches:
+  only:
+    - master
+    - rails32
+
+

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in cached_enumeration.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Peter Schrammel
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,52 @@
+# CachedEnumeration
+
+Loads your active record objects into memory so you don't have to include them.
+
+Currently only working for the ActiveRecord/Rails 4.1 series. See other branches for older Rails versions.
+
+## Warning
+Some methods (by_attributename, cached_all) were dropped as they are not needed. Forwardporting them should be
+easy.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'cached_enumeration'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install cached_enumeration
+
+## Usage
+
+    class Geneder < ActiveRecord::Base
+      cache_enumeration :order => 'name', :hashed => [:id,:name], :constantize => true
+
+
+Now the following situations are cached:
+ * `Gender.find_by(id: 1)`
+ * `Gender.find_by(name: 'male')`
+ * `Gender.where(name: 'male).first`
+ * `Gender.all`
+ * `Gender.order('name').all`
+ * `Gender::MALE`
+ * `Gender::FEMALE`
+
+If a Profile belongs_to a Gender you can simply write:
+    `profile.gender`
+end no DB query whill be executed.
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Write specs!
+5. Push to the branch (`git push origin my-new-feature`)
+6. Create new Pull Request

data/Rakefile

@@ -0,0 +1,7 @@
+require "bundler/gem_tasks"
+require 'rspec/core/rake_task'
+
+
+RSpec::Core::RakeTask.new do |t|
+
+end

data/cached_enumeration.gemspec

@@ -0,0 +1,30 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'cached_enumeration/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "cached_enumeration"
+  spec.version       = CachedEnumeration::VERSION
+  spec.authors       = ["Peter Schrammel"]
+  spec.email         = ["peter.schrammel@experteer.com"]
+  spec.description   = %q{Cache nonchanging ActiveRecord models in memory}
+  spec.summary       = %q{Cache nonchanging ActiveRecord models in memory}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec","~> 3.1"
+  spec.add_development_dependency "sqlite3","1.3.8"
+#  spec.add_development_dependency "byebug"
+#  spec.add_development_dependency "rubinius-debugger"
+  spec.add_dependency "activerecord","~> 4.1"
+
+end
+

data/lib/cached_enumeration.rb

@@ -0,0 +1,4 @@
+require 'active_record'
+require "cached_enumeration/version"
+require "cached_enumeration/cached_enumeration"
+

data/lib/cached_enumeration/cached_enumeration.rb

@@ -0,0 +1,300 @@
+module CachedEnumeration
+=begin rdoc
+provide cached access to enumeration values
+       
+usage: add cache_enumeration <params> to ActiveRecord class
+
+parameters are
+  :order  order of items in cached_all (default: 'id')
+  :hashed list of attributes to provide hashes for (default: [ 'id', 'name' ];
+  :hashed list of attributes to provide hashes for (default: [ 'id', 'name' ];
+          id will always be added to that list, if missing
+  :constantize  attribute to provide constants for (default: 'name')
+              use nil, not to generate constants
+
+cached methods are:
+find_from_ids( <id> ) or find_from_ids( [ <id>, <id>, ... ] )
+   providing cached  find( <id> ) or find( [ <id>, <id>, ... ] )
+find_by_XY / by_XY for all hashed attributes (by_XY is deprecated)
+cached_all 
+
+besides constants using the upcase name are set up providing the entries
+
+note that all objects (arrays, maps and the models themselfs) are frozen
+to avoid unintentional changes.
+
+Cachability of enumerations does not imply that all enumeration access should
+be cached. This is a question that needs to be well thought depending on the
+size of the enumeration and the number of accesses to the cached data.
+
+The by_XY finder should be avoided as the find_by_XY will be available with
+and without cache.
+=end
+  class Cache
+    attr_reader :options
+
+    def initialize(base, params)
+#      p params
+      @options=init_options(params)
+      @cache={} #cache by keys
+      @all=[] #cache of all
+      @status=:uncached #can be :uncached,:cashing,:cached
+      @klass=base
+
+      #base.extend(ClassMethods)
+      #base.reset_column_information
+      base_singleton = class << base;
+        self
+      end
+
+      patch_const_missing(base_singleton) if @options[:constantize]
+#create_find_by_methods(base_singleton)
+    end
+
+    def all
+      ensure_caches
+      @all
+    end
+
+    #returns a value from a cache
+    #@param String att name of the attribute
+    #@param String key value of the attribute
+    def get_by(att, key)
+      ensure_caches
+      key=key.to_i if att.to_s == "id"
+      @cache[att.to_s][key]
+    end
+
+    def hashed_by?(att)
+      options[:hashed].include?(att.to_s)
+    end
+
+    #forces a cache
+    #@return Boolean true is it just cached, false if it was already cached
+    def cache!
+      #only load if loading not yet in progress
+      ensure_caches if @status == :uncached
+    end
+
+    def cached?
+      @status==:cached
+    end
+
+    def order
+      @options[:order]
+    end
+
+    def first
+      @all.first
+    end
+
+    private
+
+    def ensure_caches
+      return false if cached? || caching?
+      @status=:caching
+
+      @cache = Hash.new do |hash, key|
+        hash[key]=Hash.new
+      end
+
+      # the next line is weird but I want to have to Array so I use select
+      # to dereference the relation
+      @all = @klass.order(@options[:order]).all.to_a.freeze
+
+      @all.each do |entry|
+        @options[:hashed].each do |att|
+          @cache[att.to_s][entry.send(att)] = entry.freeze
+        end
+      end
+
+      create_constants if @options[:constantize]
+
+      @klass.logger.try(:info, "Filled cache of #{@klass.name}: #{@options.inspect}")
+      @status=:cached
+      true
+    end
+
+
+    def caching?
+      @status==:caching
+    end
+
+    def init_options(params)
+      defaults = {
+        :order => 'id',
+        :hashed => ['id', 'name'],
+        :constantize => 'name',
+      }
+      #params check logic
+      params_diff=params.keys - defaults.keys
+      raise ArgumentError.new("unexpected parameters #{params_diff.inspect}, only #{defaults.keys.inspect} are understood") unless params_diff.empty?
+      params = defaults.merge(params)
+      params[:hashed] << 'id' unless params[:hashed].include? 'id'
+      params[:hashed].map! do |name|
+        name.to_s
+      end
+      params
+    end
+
+    def create_constants
+      #puts "creating constants #{self.name}"
+      proc=@options[:constantize].respond_to?(:call)
+
+      @all.each do |model|
+        const_name = if proc
+          @options[:constantize].call(model).upcase
+        else
+          model.send(@options[:constantize]).upcase
+        end
+
+        @klass.const_set const_name, model
+      end
+    end
+
+    def patch_const_missing(base_singleton)
+      # no class caching in derived classes!
+      return if @klass.parent.respond_to? :const_missing_with_cache_enumeration
+      @klass.extend ConstMissing
+      base_singleton.alias_method_chain :const_missing, :cache_enumeration
+    end
+
+    module ConstMissing
+      def const_missing_with_cache_enumeration(const_name)
+        if cache_enumeration.cache! #if we just cached
+          self.const_get(const_name) #try again
+        else
+          const_missing_without_cache_enumeration(const_name) #fails as usual
+        end
+      end
+    end
+  end
+end
+
+module ActiveRecord
+  class Relation
+    def to_a_with_cache_enumeration
+      res=nil
+
+      if cache_enumeration? && cache_enumeration.cached? && order_is_cached?
+        res=case
+          when just_modified?(:order)
+            #all and the order is cached?
+            cache_enumeration.all
+          when just_modified?(:limit, :order, :where)
+            case
+              when limit_value == 1 && where_values.blank?
+                # usually the #first case
+                [cache_enumeration.first]
+              when limit_value == 1 && where_values.present? && where_is_cached?
+                # usually "= 1" or "= ?" .first or find or find_by
+                [get_by_where]
+              when limit_value.blank? && where_values.present? && where_is_cached?
+                # usually the association case (where id in (1,2,56,6))
+                get_by_where
+              else
+                to_a_without_cache_enumeration #where is to complicated for us
+            end
+        end
+
+      end
+
+      if res #got a result the return it
+        res
+      else
+        cache_enumeration.cache! if cache_enumeration?
+        to_a_without_cache_enumeration
+      end
+
+    end
+
+    alias_method_chain :to_a, :cache_enumeration
+
+    def take_with_cache_enumeration
+      if cache_enumeration? && cache_enumeration.cached?
+        case
+          #when just_modified?(:limit)
+          #  cache_enumeration.first #tsk the first value of the default order
+          when just_modified?(:where) && where_is_cached?
+            get_by_where
+          else
+            take_without_cache_enumeration
+        end
+      else
+        cache_enumeration.cache! if cache_enumeration?
+        take_without_cache_enumeration
+      end
+    end
+
+    alias_method_chain :take, :cache_enumeration
+
+    private
+
+    def get_by_where
+      att_name=where_values[0].left.name
+      identifier = where_values[0].right
+
+      if identifier.kind_of?(Array)
+        identifier.map do |id|
+          cache_enumeration.get_by(att_name, id)
+        end.compact
+      else
+        identifier=bind_values[0][1] if identifier=='?'
+        cache_enumeration.get_by(att_name, identifier)
+      end
+    end
+
+    # just one ascending order which is the same as the cached one or none
+    def order_is_cached?
+      order_values.empty? || (
+      order_values.size == 1 &&
+        ((order_values[0].respond_to?(:ascending?) && order_values[0].ascending? &&
+          cache_enumeration.order == order_values[0].expr.name) ||
+          order_values[0] == cache_enumeration.order #sometimes the order is just as string
+        )
+      )
+    end
+
+    def where_is_cached?
+      where_values.size == 1 &&
+        where_values[0].kind_of?(Arel::Nodes::Node) &&
+        where_values[0].operator == :== &&
+        cache_enumeration.hashed_by?(where_values[0].left.name)
+    end
+
+    #*modified is an array like :limit, :where, :order, :select, :includes, :preload
+    #:readonly
+    def just_modified?(*modified)
+      return false if @klass.locking_enabled?
+      return false if limit_value.present? && !modified.include?(:limit)
+      return false if where_values.present? && !modified.include?(:where)
+      return false if order_values.present? && !modified.include?(:order)
+      return false if select_values.present? && !modified.include?(:select)
+      return false if includes_values.present? && !modified.include?(:includes)
+      return false if preload_values.present? && !modified.include?(:preload)
+      return false if readonly_value.present? && !modified.include?(:readonly)
+      return false if joins_values.present? && !modified.include?(:joins)
+      true
+    end
+  end
+
+
+  class Base
+    class << self
+      def cache_enumeration(params = {})
+        #p "init: #{params.inspect}"
+        if params.delete(:reset)
+          @cache_enumeration = nil
+        end
+
+        @cache_enumeration ||= CachedEnumeration::Cache.new(self, params)
+
+      end
+
+      def cache_enumeration?
+        @cache_enumeration.present?
+      end
+
+    end
+  end
+end

data/lib/cached_enumeration/version.rb

@@ -0,0 +1,3 @@
+module CachedEnumeration
+  VERSION = "2.0.0"
+end

data/spec/lib/association_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+
+#require 'logger'
+
+def logged
+  logger = ActiveRecord::Base.logger
+  ActiveRecord::Base.logger=Logger.new(STDOUT)
+  ActiveRecord::Base.logger.level=Logger::DEBUG
+  yield
+  ActiveRecord::Base.logger=logger
+end
+
+describe 'association caching' do
+  before :all do
+    ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+#    ActiveRecord::Base.logger=Logger.new(STDOUT)
+#    ActiveRecord::Base.logger.level=Logger::DEBUG
+
+    ActiveRecord::Migration.create_table :genders do |t|
+#      t.integer :id
+      t.string :name
+    end
+
+    class Gender < ActiveRecord::Base
+      cache_enumeration
+    end
+
+    Gender.create!(:name => 'male')
+    Gender.create!(:name => 'female')
+    Gender.cache_enumeration.cache!
+
+    ActiveRecord::Migration.create_table :profiles do |t|
+ #     t.integer :id
+      t.string :name
+      t.integer :gender_id
+    end
+    class Profile < ActiveRecord::Base
+      belongs_to :gender
+    end
+    Profile.delete_all
+  end
+
+
+  let(:him) { Profile.create(:name => 'Him', :gender => Gender::MALE) }
+  let(:her) { Profile.create(:name => 'Her', :gender => Gender::FEMALE) }
+
+
+  context "should use cached when going over association" do
+
+    it 'should find the cached ones (no :include)' do
+      him
+      him.reload #to empty the assoc cache
+
+      Gender.connection.should_not_receive(:exec_query)
+      him.gender.name.should == 'male'
+    end
+
+=begin
+
+does not work: Profile.includes(:gender).all creates two sql statements
+to load profiles AND genders associated to them. The 2nd one (for genders)
+does not run through standard finders but is done in the depth of AR.
+So caching does not work here.
+
+Possible improvements:
+* intercept `all' for ALL AR models and take out inclusions where the
+  model is cached (restricted to simple cases of belongs_to)
+* find an entry point deeper in AR where associations are loaded and
+  modify that to consider model caching
+
+Until then, one should just leave out cached models in inclusions,
+though that makes switching caching on or off for a model quite difficult.
+
+    it "should take the :include from the cache" do
+      #logged do
+      him;her
+        ActiveRecord::Base.connection.should_receive(:exec_query).once.and_call_original
+        all=Profile.includes(:gender).all
+        ActiveRecord::Base.connection.should_not_receive(:exec_query)
+        him.gender.name.should == 'male'
+        her.gender.name.should == 'female'
+      #end
+    end
+=end
+
+
+  end
+end

data/spec/lib/cached_enumeration_spec.rb

@@ -0,0 +1,205 @@
+require 'spec_helper'
+
+
+describe 'simple caching' do
+  before :all do
+    ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+    ActiveRecord::Migration.create_table :models do |t|
+#      t.integer :id
+      t.string :name
+      t.string :other
+    end
+  end
+
+
+  before do
+    @klass=Class.new(ActiveRecord::Base)
+    @klass.table_name="models"
+    @klass.delete_all
+    @klass.create(:name => 'one', :other => 'eins')
+    @klass.create(:name => 'two', :other => 'zwei')
+    @klass.create(:name => 'three', :other => 'drei')
+  end
+
+  let(:one) { @klass.find_by(:name => "one") }
+  let(:three) { @klass.find_by(:name => "three") }
+  let(:two) { @klass.find_by(:name => "two") }
+
+  context "cache_enumeration?" do
+    it "should return the rigth value" do
+      @klass.should_not be_cache_enumeration
+      @klass.cache_enumeration.cache!
+      @klass.should be_cache_enumeration
+    end
+    it "should not cache if not activated" do
+      @klass.all
+      @klass.should_not be_cache_enumeration
+    end
+  end
+
+
+  context "all" do
+    before do
+      @klass.cache_enumeration(:constantize => false)
+    end
+
+    it "should fire db queries if all is modified" do
+      @klass.cache_enumeration.cache!
+      @klass.connection.should_receive(:exec_query).and_call_original
+      @klass.where("name in ('one','two')").all.size.should == 2
+    end
+
+    it 'should fire db queries if all has parameters' do
+      @klass.cache_enumeration.cache!
+      #@klass.connection.should_receive(:exec_query)..and_call_original
+      @klass.where("name = 'one'").all.size.should == 1
+    end
+
+    it 'should fire db queries if all with parameters is used through find(:all)' do
+      @klass.cache_enumeration.cache!
+      @klass.connection.should_receive(:exec_query).and_call_original
+      @klass.where("name = 'one'").all.size.should == 1
+    end
+      
+    it 'should fire db queries if all with select parameter is used through find(:all)' do
+      @klass.cache_enumeration.cache!
+      @klass.connection.should_receive(:exec_query).and_call_original
+      entry = @klass.select("id, name").all.first
+      lambda {
+        entry.other
+      }.should raise_error(ActiveModel::MissingAttributeError, 'missing attribute: other')
+    end
+      
+  end
+
+  context 'first' do
+    it 'should find the first entry' do
+      @klass.cache_enumeration.cache!
+      @klass.first.should == one
+    end
+    it 'should allwo string order (and use cache)' do
+      @klass.cache_enumeration(:order => "other").cache!
+      @klass.connection.should_not_receive(:exec_query)
+
+      @klass.order('other').first.should == three
+    end
+    it 'should allow hash condition (and use cache)' do
+      @klass.cache_enumeration.cache!
+      @klass.connection.should_not_receive(:exec_query)
+
+      @klass.where(:name => 'three').first.should == three
+    end
+    it 'should allow string conditions (and ask db)' do
+      @klass.cache_enumeration.cache!
+      @klass.connection.should_receive(:exec_query).and_call_original
+      @klass.where("other = 'drei'").first.should == three
+    end
+
+    it 'should allow hash conditions in first (and use cache)' do
+      @klass.cache_enumeration.cache!
+      @klass.connection.should_not_receive(:exec_query)
+      @klass.where(:name => 'three' ).first.should == three
+    end
+
+    it 'should allow conditions for first (and use db)' do
+      @klass.cache_enumeration.cache!
+      @klass.connection.should_receive(:exec_query).and_call_original
+      @klass.where("other = 'drei'").first.should == three
+    end
+    it 'should allow conditions for first (and use db)' do
+      @klass.cache_enumeration.cache!
+      @klass.connection.should_receive(:exec_query).and_call_original
+      expect(@klass.where("name = 'three'").first).not_to be_nil
+    end
+  end
+
+  context "finders" do
+    before do
+      @klass.cache_enumeration(:constantize => false)
+    end
+
+    it 'should find objects providing id' do
+      @klass.cache_enumeration.cache!
+      @klass.connection.should_not_receive(:exec_query)
+
+      @klass.find(one.id).id.should == one.id
+      @klass.find(one.id).frozen?().should eq(true)
+      @klass.find([one.id])[0].id.should == one.id
+      @klass.find([]).size.should == 0
+
+      lambda { @klass.find(0) }.should raise_error(ActiveRecord::RecordNotFound)
+      lambda { @klass.find(nil) }.should raise_error(ActiveRecord::RecordNotFound)
+    end
+
+    it "should find an array of object ids (and hit cache)" do
+      @klass.cache_enumeration.cache!
+      @klass.connection.should_not_receive(:exec_query)
+
+      @klass.find([one.id, three.id]).collect { |item| item.id }.should == [one.id, three.id]
+    end
+
+    it 'should find_by' do
+      @klass.cache_enumeration.cache!
+      @klass.connection.should_not_receive(:exec_query)
+
+      @klass.find_by(:id => one.id).id.should == one.id
+      @klass.find_by(:id => one.id.to_s).id.should == one.id
+      @klass.find_by(:id => 0).should be_nil
+    end
+
+    it 'should find objects by_name' do
+      one
+      @klass.cache_enumeration.cache!
+      @klass.connection.should_not_receive(:exec_query)
+
+      @klass.find_by(:name => 'one').id.should == one.id
+      @klass.find_by(:name => 'no such name').should be_nil
+    end
+
+  end
+
+  context "multiple keys" do
+    it 'it should store by multiple keys (hashing)' do
+      @klass.cache_enumeration(:hashed => ['id', 'other', 'name']).cache!
+      @klass.connection.should_not_receive(:exec_query)
+      @klass.find_by(:other => 'eins').id.should ==one.id
+      @klass.find_by(:name => 'one').id.should ==one.id
+    end
+  end
+  context "sorting of all" do
+    it 'should sort by option' do
+      @klass.cache_enumeration(:order => 'name').cache!
+      @klass.connection.should_not_receive(:exec_query)
+
+      @klass.order("name").all.collect { |item| item.id }.should == [one.id, three.id, two.id]
+    end
+
+  end
+  context "constantize" do
+    it "should constantize name by default" do
+      @klass.cache_enumeration.options[:constantize].should == 'name'
+    end
+    it "should without no preloading" do
+
+      @klass.cache_enumeration
+      @klass::ONE.id.should == one.id
+    end
+
+    it 'should constantize other fields' do
+      @klass.cache_enumeration(:constantize => 'other').cache!
+      @klass.cache_enumeration.options[:constantize].should == 'other'
+      @klass.connection.should_not_receive(:exec_query)
+
+      @klass::EINS.id.should == one.id
+    end
+
+    it "should contantize by lambda" do
+      @klass.cache_enumeration(:constantize => lambda { |model| model.other }).cache!
+      @klass.connection.should_not_receive(:exec_query)
+
+      @klass::EINS.id.should == one.id
+    end
+  end
+
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,27 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'cached_enumeration'
+#require 'byebug'
+#require 'rubinius/debugger'
+require 'logger'
+#ActiveRecord::Base.logger=Logger.new(STDOUT)
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end
+

metadata

@@ -0,0 +1,115 @@
+--- !ruby/object:Gem::Specification 
+name: cached_enumeration
+version: !ruby/object:Gem::Version 
+  version: 2.0.0
+platform: ruby
+authors: 
+- Peter Schrammel
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2014-10-23 00:00:00 Z
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "1.3"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - &id006 
+      - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "3.1"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: sqlite3
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        version: 1.3.8
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: activerecord
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        version: "4.1"
+  type: :runtime
+  version_requirements: *id005
+description: Cache nonchanging ActiveRecord models in memory
+email: 
+- peter.schrammel@experteer.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- cached_enumeration.gemspec
+- lib/cached_enumeration.rb
+- lib/cached_enumeration/cached_enumeration.rb
+- lib/cached_enumeration/version.rb
+- spec/lib/association_spec.rb
+- spec/lib/cached_enumeration_spec.rb
+- spec/spec_helper.rb
+homepage: ""
+licenses: 
+- MIT
+metadata: {}
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id006
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - *id006
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Cache nonchanging ActiveRecord models in memory
+test_files: 
+- spec/lib/association_spec.rb
+- spec/lib/cached_enumeration_spec.rb
+- spec/spec_helper.rb
+has_rdoc: