cache-machine 0.1.10 → 0.2.0

data/spec/lib/cache_machine/cache/scope_spec.rb

@@ -0,0 +1,50 @@
+require "spec_helper"
+
+describe CacheMachine::Cache::Scope do
+  let(:cacher_under_scope_one) { Cacher.create :name => 'one'  }
+  let(:cacher_under_scope_two) { Cacher.create :name => 'two'  }
+  let(:cacher_outside_scope  ) { Cacher.create :name => 'tree' }
+
+  let(:join_under_scope_one) { Join.create :cacher => cacher_under_scope_one }
+  let(:join_under_scope_two) { Join.create :cacher => cacher_under_scope_two }
+  let(:join_outside_scope)   { Join.create :cacher => cacher_outside_scope   }
+
+  before :each do
+    CacheMachine::Cache::Mapper.new do
+      resource Cacher, :scopes => :test_scope do
+        collection :joins, :scopes => :test_scope
+      end
+    end
+  end
+
+  it "works" do
+    Cacher.should respond_to(:cache_scopes)
+    Cacher.should respond_to(:under_cache_scopes)
+  end
+
+  describe "::under_cache_scopes" do
+    context "for resources" do
+      before :each do
+        cacher_under_scope_one
+        cacher_under_scope_two
+        cacher_outside_scope
+      end
+
+      it "works" do
+        Cacher.under_cache_scopes.all.should =~ [cacher_under_scope_one, cacher_under_scope_two]
+      end
+    end
+
+    context "for collections" do
+      before :each do
+        join_under_scope_one
+        join_under_scope_two
+        join_outside_scope
+      end
+
+      it "works" do
+        Join.under_cache_scopes.all.should =~ [join_under_scope_one, join_under_scope_two]
+      end
+    end
+  end
+end

data/spec/lib/cache_machine/cache/timestamp_builder_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+describe CacheMachine::Cache::TimestampBuilder do
+  describe "::define_timestamp" do
+    before :each do
+      Cacher.stamp = 0
+      Cacher.define_timestamp(:test_timestamp) { stamp }
+    end
+
+    it "works" do
+      Cacher.should respond_to :resource_test_timestamp
+      Cacher.should respond_to :test_timestamp
+      Object.should_not respond_to :test_timestamp
+    end
+
+    it "returns current time value if cache is clear" do
+      Time.stub("now").and_return 1
+      Cacher.test_timestamp.should == "1"
+    end
+
+    context "key" do
+      it "works" do
+        CacheMachine::Cache::timestamps_adapter.should_receive(:fetch_timestamp).with(Cacher.timestamp_key_of("test_timestamp"))
+        CacheMachine::Cache::timestamps_adapter.should_receive(:fetch_timestamp).with(Cacher.timestamp_key_of("test_timestamp_0_stamp"), {})
+        Cacher.test_timestamp
+      end
+
+      it "changes value" do
+        Cacher.stamp = 1
+
+        CacheMachine::Cache::timestamps_adapter.should_receive(:fetch_timestamp).with(Cacher.timestamp_key_of("test_timestamp"))
+        CacheMachine::Cache::timestamps_adapter.should_receive(:fetch_timestamp).with(Cacher.timestamp_key_of("test_timestamp_1_stamp"), {})
+        Cacher.test_timestamp
+      end
+    end
+
+    it "returns value from cache" do
+      Cacher.test_timestamp
+      CacheMachine::Cache::timestamps_adapter.should_not_receive(:reset_timestamp)
+      Cacher.test_timestamp
+    end
+
+    it "expires old timestamp" do
+      Cacher.test_timestamp
+      CacheMachine::Cache::timestamps_adapter.should_receive(:reset_timestamp).with("Cacher~test_timestamp~ts")
+      CacheMachine::Cache::timestamps_adapter.should_receive(:reset_timestamp).with("Cacher~test_timestamp_0_stamp~ts")
+
+      Cacher.stamp = 1
+      Cacher.test_timestamp
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -8,8 +8,14 @@ require "cache-machine"
 RSpec.configure { |config| config.mock_with :rspec }
 
 ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => "db/sqlite3.test.db")
-CacheMachine::Logger.level = :info
-CacheMachine::Cache.formats = [:ehtml, :json]
-ActiveRecord::Base.logger = Logger.new(STDOUT)
+
+CacheMachine::Logger.level  = :info
 
 Object.const_set "RAILS_CACHE", ActiveSupport::Cache.lookup_store(:memory_store) # You can set memcached
+
+::Rails.cache.clear
+
+ActiveRecord::Base.logger = Logger.new(nil)
+CacheMachine::Logger.logger = Logger.new(nil)
+
+require 'fixtures'

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: cache-machine
 version: !ruby/object:Gem::Version 
-  hash: 15
+  hash: 23
   prerelease: 
   segments: 
   - 0
-  - 1
-  - 10
-  version: 0.1.10
+  - 2
+  - 0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Sergei Zinin
@@ -16,8 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-10-22 00:00:00 +08:00
-default_executable: 
+date: 2012-03-05 00:00:00 Z
 dependencies: 
 - !ruby/object:Gem::Dependency 
   name: rails
@@ -27,44 +26,16 @@ dependencies:
     requirements: 
     - - ">="
       - !ruby/object:Gem::Version 
-        hash: 3
+        hash: 5
         segments: 
-        - 0
-        version: "0"
+        - 3
+        version: "3"
   type: :runtime
   version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: activemodel
-  prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :runtime
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
-  name: activesupport
-  prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
-  type: :runtime
-  version_requirements: *id003
 - !ruby/object:Gem::Dependency 
   name: bundler
   prerelease: false
-  requirement: &id004 !ruby/object:Gem::Requirement 
+  requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
@@ -76,52 +47,55 @@ dependencies:
         - 0
         version: 1.0.0
   type: :development
-  version_requirements: *id004
-- !ruby/object:Gem::Dependency 
-  name: jeweler
-  prerelease: false
-  requirement: &id005 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 11
-        segments: 
-        - 1
-        - 6
-        - 2
-        version: 1.6.2
-  type: :development
-  version_requirements: *id005
+  version_requirements: *id002
 description: A Ruby on Rails framework to support cache management based on explicitely modeled caching dependencies.
-email: kgoslar@partyearth.com
+email: szinin@partyearth.com
 executables: []
 
 extensions: []
 
 extra_rdoc_files: 
 - LICENSE.txt
-- README.rdoc
+- README.md
 files: 
 - .gitignore
+- .travis.yml
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
-- README.rdoc
+- README.md
 - Rakefile
 - VERSION
 - cache-machine.gemspec
+- db/.gitignore
 - lib/cache-machine.rb
+- lib/cache_machine/adapter.rb
+- lib/cache_machine/adapters/rails.rb
 - lib/cache_machine/cache.rb
+- lib/cache_machine/cache/associations.rb
+- lib/cache_machine/cache/class_timestamp.rb
+- lib/cache_machine/cache/collection.rb
 - lib/cache_machine/cache/map.rb
+- lib/cache_machine/cache/mapper.rb
+- lib/cache_machine/cache/resource.rb
+- lib/cache_machine/cache/scope.rb
+- lib/cache_machine/cache/timestamp_builder.rb
 - lib/cache_machine/helpers.rb
 - lib/cache_machine/helpers/cache_helper.rb
 - lib/cache_machine/logger.rb
 - lib/cache_machine/railtie.rb
+- lib/cache_machine/tasks.rb
 - spec/fixtures.rb
-- spec/lib/cache_machine_spec.rb
+- spec/lib/cache_machine/adapters/rails_spec.rb
+- spec/lib/cache_machine/cache/associations_spec.rb
+- spec/lib/cache_machine/cache/class_timestam_spec.rb
+- spec/lib/cache_machine/cache/collection_spec.rb
+- spec/lib/cache_machine/cache/map_spec.rb
+- spec/lib/cache_machine/cache/mapper_spec.rb
+- spec/lib/cache_machine/cache/resource_spec.rb
+- spec/lib/cache_machine/cache/scope_spec.rb
+- spec/lib/cache_machine/cache/timestamp_builder_spec.rb
 - spec/spec_helper.rb
-has_rdoc: true
 homepage: http://github.com/partyearth/cache-machine
 licenses: 
 - MIT
@@ -151,7 +125,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.5.0
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: A Ruby on Rails framework to support cache management based on explicitely modeled caching dependencies.

data/README.rdoc

@@ -1,186 +0,0 @@
-= cache-machine
-http://img195.imageshack.us/img195/5371/cachemachinefinal2.png
-
-An ActiveRecord mixin that helps managing cached content in a Ruby on Rails application with complex data update dependencies.
-
-Cache Machine provides
-* high-level methods for accessing cached content using page names, numbers, time stamps etc,
-* a DSL to describe update dependencies between the data models underlying the cached content,
-* automatic cache invalidation based on those explicitly modeled data update dependencies.
-
-You will find Cache Machine useful if you:
-* use Memcache to cache fragments of a web site that contain data from a variety of underlying data models
-* anytime one of the underlying data models changes, all the cached page fragments in which this data model occurs - and only those - need to be invalidated/updated
-* you have many data models, cached fragments, and many data models used inside each cached fragment
-
-Cache Machine depends only on the Rails.cache API and is thereby library agnostic.
-
-= Usage
-
-  # Fetch cache of venues collection on model_instance.
-  @neighborhood.fetch_cache_of(:venues) { venues }
-
-  # Specify format.
-  @neighborhood.fetch_cache_of(:venues, :format => :json) { venues.to_json }
-
-  # Paginated content.
-  @neighborhood.fetch_cache_of(:venues, :page => 2) { venues.paginate(:page => 2) }
-
-In you target model define <b>cache map</b>:
-
-  cache_map :venues  => [:hotspots, :today_events],
-            :cities  => [:venues],
-            :streets => :hotspots,
-            :users
-
-This example shows you how changes of one collection affect on invalidation process.
-For each record of your target model:
-- Cache for <b>users</b> collection associated with object of your target model is invalidated when changing (_add_, _remove_, _update_) the _users_ collection
-- Cache for <b>venues</b> collection associated with object of your target model is invalidated when changing the _venues_ collection associated with that object
-- Cache for <b>venues</b> collection associated with object of your target model is invalidated when changing the _cities_ collection. In this case machine automatically invalidates _hotspots_ and _today_events_
-- Cache for <b>cities</b> collection associated with object of your target model is invalidated when changing the _cities_ collection
-- Cache for <b>hotspots</b> collection is invalidated when changing the _venues_ collection
-- Cache for <b>hotspots</b> collection is invalidated when changing the _streets_ collection
-- Cache for <b>hotspots</b> collection is invalidated when changing the _cities_ collection
-- Cache for <b>today_events</b> collection is invalidated when changing the _venues_ collection
-- Cache for <b>today_events</b> collection is invalidated when changing the _cities_ collection
-<b>Cache map may contain any name, whatever you want. But invalidation process starts only when ActiveRecord collection is changed.</b>
-
-== Custom cache invalidation
-
-=== Using timestamps
-Suppose you need to reset cache of _schedule_of_events_ every day.
-
-  @lady_gaga.fetch_cache_of :schedule_of_events, :timestamp => lambda { Date.today } do
-    @lady_gaga.events.where(:date.gt => Date.today)
-  end
-
-=== Using Cache Machine timestamps
-Suppose you need to reset cache of _tweets_ every 10 minutes.
-
-  class LadyGagaPerformer < ActiveRecord::Base
-    define_timestamp :tweets_timestamp, :expires_in => 10.minutes
-  end
-
-  #...
-
-  # Somewhere
-  @lady_gaga.fetch_cache_of :tweets, :timestamp => :tweets_timestamp do
-    TwitterApi.fetch_tweets_for @lady_gaga
-  end
-
-Suppose you need custom timestamp value.
-
-  class LadyGagaPerformer < ActiveRecord::Base
-    define_timestamp(:tweets_timestamp) { Time.now.to_i + self.id }
-  end
-
-  #...
-
-  # Somewhere
-  @lady_gaga.fetch_cache_of :tweets, :timestamp => :tweets_timestamp do
-    TwitterApi.fetch_tweets_for @lady_gaga
-  end
-
-Note what timestamp declarations work in object scope. Lets take an example:
-
-  class LadyGagaPerformer < ActiveRecord::Base
-    define_timestamp (:tweets_timestamp) { tweets.last.updated_at.to_i }
-
-    has_many :tweets
-  end
-
-  class Tweet < ActiveRecord::Base
-    belongs_to :lady_gaga_performer
-  end
-
-=== Using methods as timestamps
-Suppose you have your own really custom cache key.
-
-  class LadyGagaPerformer < ActiveRecord::Base
-    def my_custom_cache_key
-      rand(100) + rand(1000) + rand(10000)
-    end
-  end
-
-  #...
-
-  # Somewere
-  @lady_gaga.fetch_cache_of(:something, :timestamp => :my_custom_cache_key) { '...' }
-
-=== Using class timestamps
-Suppose you need to fetch cached content of one of your collections.
-  Rails.cache.fetch(MyModel.timestamped_key) { '...' }
-
-Want to see collection timestamp?
-  MyModel.timestamp
-
-=== Manual cache invalidation
-  # For classes.
-  MyModel.reset_timestamp
-
-  # For collections.
-  @lady_gaga.delete_cache_of :events
-
-  # For timestamps.
-  @lady_gaga.reset_timestamp_of :events
-
-  # You can reset all associated caches using map.
-  @lady_gaga.delete_all_caches
-
-== Cache formats
-Cache Machine invalidates cache using a couple of keys with the different formats.
-Default formats are:
-- EHTML
-- HTML
-- JSON
-- XML
-
-This means you call 5 times for cache invalidation (1 time without specifying format) with different keys. Sometimes it is too much. Cache machine allows you to set your own formats. Just place in your environment config or in initializer the following:
-  CacheMachine::Cache.formats = [:doc, :pdf]
-
-Or if you do not want to use formats at all:
-  CacheMachine::Cache.formats = nil
-
-Then use:
-
-  @lady_gaga.fetch_cache_of(:new_songs, :format => :doc) { "LaLaLa".to_doc }
-  @lady_gaga.fetch_cache_of(:new_songs, :format => :pdf) { "GaGaGa".to_pdf }
-
-Cache Machine will invalidate cache for each format you specified in config.
-
-== Working with paginated content
-Suppose you installed WillPaginate gem and want to cache each page with fetched results separately.
-  class TweetsController < ApplicationController
-
-    def index
-      @tweets = @lady_gaga.fetch_cache_of(:tweets, :page => params[:page]) do
-        Tweet.all.paginate(:page => params[:page])
-      end
-    end
-  end
-
-Cache Machine will use <tt>:page</tt> as a part of cache key and will invalidate each page on any change in associated collection.
-
-== ActionView helper
-From examples above:
-  <%= cache_for @lady_gaga, :updoming_events do %>
-    <p>Don't hide yourself in regret
-       Just love yourself and you're set</p>
-  <% end %>
-<tt>cache_for</tt> method automatically sets EHTML format on cache key.
-
-
-== Contributing to cache-machine
-
-* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
-* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
-* Fork the project
-* Start a feature/bugfix branch
-* Commit and push until you are happy with your contribution
-* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
-* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
-
-== Copyright
-
-Copyright (c) 2011 PartyEarth LLC. See LICENSE.txt for details.