cached-models 0.0.2

data/CHANGELOG

@@ -0,0 +1,84 @@
+*0.0.2 (October 10th, 2008)*
+
+* Updated README with new installation instructions
+
+* Created separated folder for ActiveRecord
+
+* Added dist related Rake tasks
+
+* Added gem related files
+
+* Added Git related Rake tasks
+
+* Removed default configuration for cache lookup
+
+* Make sure cache is always used by all the instances which reference the same record
+
+* Made independent of Rails
+
+* Allow test suite to work without any active cache server
+
+* Enhanced AssociationCollection test coverage
+
+* ActiveRecord::Base#expire_cache_for now uses the new cache access API
+
+* Abstracted ActiveRecord::Base#cache_fetch in order to normalize cache access for <reflection_name>_ids
+
+* Reduced the amount of cache hits, caching the status of cached relations with ActiveRecord::Base#cached_associations
+
+
+
+*0.0.1 (September 10th, 2008)*
+
+* Updated README with project informations
+
+* Make sure 'test' is the default Rake task
+
+* Added project description to README. Added about.yml.
+
+* Updated README with informations about required environment settings
+
+* Only load the plugin if the current environment has the cache turned on
+
+* Added support for cache expiration on after_save callback
+
+* Make sure to use ActiveRecord cache proxy for test suite
+
+* Make sure test suite will run using RAILS_ENV in test mode
+
+* Added support for scoped finders in AssociationCollection. Fixed cache renewal for AssociationCollection#delete.
+
+* Added support for cache renewal on AssociationCollection methods
+
+* Added support for cache expiration on direct associated objects updates
+
+* Updated README example
+
+* Removed CacheObserver. Fixed cache expiration for has_many relation.
+
+* Introducing CacheObserver in order to transparently handle cache expiring for has_many macro
+
+* Test enhancements for AssociationCollection#<< on polymorphic associations
+
+* Test enhancements for AssociationCollection#<<. Make sure to expire caches when an associated object changes owner.
+
+  class Author < ActiveRecord::Base
+    has_many :posts, :cached => true
+  end
+
+  post = author.posts.last
+  another_author.posts << post # => refresh both author and another_author caches
+
+* AssociationCollection#<< support
+
+  class Author < ActiveRecord::Base
+    has_many :posts, :cached => true
+  end
+
+  author.posts << post # => causes a refresh of cached posts
+
+* has_many association support
+  
+  class Author < ActiveRecord::Base
+    has_many :posts, :cached => true
+  end

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2008 Luca Guidi
+
+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

@@ -0,0 +1,95 @@
+= CachedModels
+
+CachedModels provides to your models a transparent approach to use Rails internal caching mechanism.
+
+Check for news and tutorials at the {project home page}[http://www.lucaguidi.com/pages/cached_models].
+
+
+
+= Usage
+
+Using Memcached and Rails 2.2.1
+
+Make sure to configure your current environment with:
+
+config.cache_classes = true
+config.action_controller.perform_caching = true
+config.cache_store = :mem_cache_store
+
+
+
+class Project < ActiveRecord::Base
+  has_many :developers, :cached => true
+  has_many :tickets, :cached => true
+  has_many :recent_tickets, :limit => 5,
+    :order => 'id DESC', :cached => true
+    
+end
+
+class Developer < ActiveRecord::Base
+  belongs_to :project, :cached => true
+end
+
+
+Example 1
+  project.developers # Database fetch and automatic cache storing
+
+  developer = project.developers.last
+  developer.update_attributes :first_name => 'Luca' # Database update and cache expiration for project cache
+
+Example 2
+  project2.developers # Database fetch and automatic cache storing
+  project2.developers << developer # Database update and cache renewal for both project and project2 caches
+
+Example 3
+  project.tickets # Database fetch and automatic cache storing
+  ticket = project.recent_tickets.first
+  ticket.update_attributes :state => 'solved' # Database update and cache expiration for both tickets and recent_tickets entries
+
+
+= Install
+
+There are three ways to install CachedModels
+
+Gemified plugin:
+
+  environment.rb
+
+    Rails::Initializer.run do |config|
+      config.gem 'cached-models'
+    end
+
+  $ (sudo) rake gems:install
+  $ rake gems:unpack
+
+Rails plugin:
+
+  $ ./script/plugin install git://github.com/jodosha/cached-models.git
+
+Standalone:
+
+  $ (sudo) gem install cached-models
+  
+  in your project:
+  
+    require 'rubygems'
+    require 'activerecord'
+    require 'cached-models'
+
+    ActiveRecord::Base.rails_cache = ActiveSupport::Cache.lookup_store(:mem_cache_store, 'localhost')
+  
+
+
+= Contribute
+
+* Check out the code and test it:
+  $ git clone git://github.com/jodosha/cached-models.git
+  $ rake cached_models
+
+* Create a ticket to the {Sushistar Lighthouse page}[http://sushistar.lighthouseapp.com]
+
+* Create a patch and add as attachment to the ticket.
+
+
+
+Copyright (c) 2008 Luca Guidi, released under the MIT license

data/Rakefile

@@ -0,0 +1,81 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+version = '0.0.2'
+repositories = %w( origin rubyforge )
+
+desc 'Default: run unit tests.'
+task :default => :test
+
+desc 'Test the cached_models plugin.'
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = true
+end
+
+desc 'Generate documentation for the cached_models plugin.'
+Rake::RDocTask.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'CachedModels'
+  rdoc.options << '--line-numbers' << '--inline-source'
+  rdoc.rdoc_files.include('README')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+desc 'Build and install the gem (useful for development purposes).'
+task :install do
+  system "gem build cached-models.gemspec"
+  system "sudo gem uninstall cached-models"
+  system "sudo gem install --local --no-rdoc --no-ri cached-models-#{version}.gem"
+  system "rm cached-models-*.gem"
+end
+
+desc 'Build and prepare files for release.'
+task :dist => :clean do
+  require 'cached-models'
+  system "gem build cached-models.gemspec"
+  system "cd .. && tar -czf cached-models-#{version}.tar.gz cached_models"
+  system "cd .. && tar -cjf cached-models-#{version}.tar.bz2 cached_models"
+  system "cd .. && mv cached-models-* cached_models"
+end
+
+desc 'Clean the working copy from release files.'
+task :clean do
+  system "rm cached-models-#{version}.gem"     if File.exist? "cached-models-#{version}.gem"
+  system "rm cached-models-#{version}.tar.gz"  if File.exist? "cached-models-#{version}.tar.gz"
+  system "rm cached-models-#{version}.tar.bz2" if File.exist? "cached-models-#{version}.tar.bz2"
+end
+
+desc 'Show the file list for the gemspec file'
+task :files do
+  puts "Files:\n #{Dir['**/*'].reject {|f| File.directory?(f)}.sort.inspect}"
+  puts "Test files:\n #{Dir['test/**/*_test.rb'].reject {|f| File.directory?(f)}.sort.inspect}"
+end
+
+namespace :git do
+  desc 'Push local Git commits to all remote centralized repositories.'
+  task :push do
+    repositories.each do |repository|
+      puts "Pushing #{repository}...\n"
+      system "git push #{repository} master"
+    end
+  end
+  
+  desc 'Perform a git-tag'
+  task :tag do
+    puts "Please enter the tag name: "
+    tag_name = STDIN.gets.chomp
+    exit(1) if tag_name.nil? or tag_name.empty?
+    system %(git tag -s #{tag_name} -m "Tagged #{tag_name}")
+  end
+  
+  desc 'Push all the tags to remote centralized repositories.'
+  task :push_tags do
+    repositories.each do |repository|
+      puts "Pushing tags to #{repository}...\n"
+      system "git push --tags #{repository}"
+    end
+  end
+end

data/about.yml

@@ -0,0 +1,8 @@
+author: Luca Guidi
+email: guidi.luca@gmail.com
+homepage: http://lucaguidi.com/pages/cached_models
+summary: CachedModels provides to your models a transparent approach to use Rails internal caching mechanism.
+description: CachedModels provides to your models a transparent approach to use Rails internal caching mechanism.
+license: MIT
+rails_version: 2.1.1+
+version: 0.0.1

data/cached-models.gemspec

@@ -0,0 +1,19 @@
+Gem::Specification.new do |s|
+  s.name               = "cached-models"
+  s.version            = "0.0.2"
+  s.date               = "2008-10-10"
+  s.summary            = "Transparent caching policy for your models"
+  s.author             = "Luca Guidi"
+  s.email              = "guidi.luca@gmail.com"
+  s.homepage           = "http://lucaguidi.com/pages/cached_models"
+  s.description        = "CachedModels provides to your ActiveRecord models a transparent approach to use ActiveSupport caching mechanism."
+  s.has_rdoc           = true
+  s.rubyforge_project  = %q{cached-models}
+  s.files              = ["CHANGELOG", "MIT-LICENSE", "README", "Rakefile", "about.yml", "cached-models.gemspec", "init.rb", "install.rb", "lib/activerecord/lib/active_record.rb", "lib/activerecord/lib/active_record/associations.rb", "lib/activerecord/lib/active_record/associations/association_collection.rb", "lib/activerecord/lib/active_record/associations/association_proxy.rb", "lib/activerecord/lib/active_record/associations/has_many_association.rb", "lib/activerecord/lib/active_record/base.rb", "lib/cached-models.rb", "lib/cached_models.rb", "setup.rb", "tasks/cached_models_tasks.rake", "test/active_record/associations/has_many_association_test.rb", "test/active_record/base_test.rb", "test/fixtures/authors.yml", "test/fixtures/blogs.yml", "test/fixtures/comments.yml", "test/fixtures/posts.yml", "test/fixtures/tags.yml", "test/models/author.rb", "test/models/blog.rb", "test/models/comment.rb", "test/models/post.rb", "test/models/tag.rb", "test/test_helper.rb", "uninstall.rb"]
+  s.test_files         = ["test/active_record/associations/has_many_association_test.rb",
+    "test/active_record/base_test.rb"]
+  s.extra_rdoc_files   = ['README', 'CHANGELOG']
+  
+  s.add_dependency("activesupport", ["> 2.1.0"])
+  s.add_dependency("activerecord",  ["> 2.1.0"])
+end

data/init.rb

@@ -0,0 +1,2 @@
+# Include hook code here
+require 'cached_models'

data/install.rb

@@ -0,0 +1 @@
+# Install hook code here

data/lib/activerecord/lib/active_record/associations/association_collection.rb

@@ -0,0 +1,95 @@
+require 'set'
+
+module ActiveRecord
+  module Associations
+    class AssociationCollection < AssociationProxy #:nodoc:
+      def find(*args)
+        expects_array = args.first.kind_of?(Array)
+        ids           = args.flatten.compact.uniq.map(&:to_i)
+
+        if @reflection.options[:cached]
+          result = @owner.send(:cache_read, @reflection)
+          if result
+            result = result.select { |record| ids.include? record.id }
+            result = expects_array ? result : result.first
+            return result
+          end
+        end
+
+        options = args.extract_options!
+
+        # If using a custom finder_sql, scan the entire collection.
+        if @reflection.options[:finder_sql]
+          if ids.size == 1
+            id = ids.first
+            record = load_target.detect { |r| id == r.id }
+            expects_array ? [ record ] : record
+          else
+            load_target.select { |r| ids.include?(r.id) }
+          end
+        else
+          conditions = "#{@finder_sql}"
+          if sanitized_conditions = sanitize_sql(options[:conditions])
+            conditions << " AND (#{sanitized_conditions})"
+          end
+
+          options[:conditions] = conditions
+
+          if options[:order] && @reflection.options[:order]
+            options[:order] = "#{options[:order]}, #{@reflection.options[:order]}"
+          elsif @reflection.options[:order]
+            options[:order] = @reflection.options[:order]
+          end
+
+          # Build options specific to association
+          construct_find_options!(options)
+
+          merge_options_from_reflection!(options)
+
+          # Pass through args exactly as we received them.
+          args << options
+          @reflection.klass.find(*args)
+        end
+      end
+
+      # Add +records+ to this association.  Returns +self+ so method calls may be chained.  
+      # Since << flattens its argument list and inserts each record, +push+ and +concat+ behave identically.
+      def <<(*records)
+        result = true
+        load_target if @owner.new_record?
+
+        @owner.transaction do
+          flatten_deeper(records).each do |record|
+            raise_on_type_mismatch(record)
+            add_record_to_target_with_callbacks(record) do |r|
+              result &&= insert_record(record) unless @owner.new_record?
+            end
+          end
+        end
+
+        @owner.send(:cache_write, @reflection, self) if @reflection.options[:cached]
+
+        result && self
+      end
+
+      # Returns the size of the collection by executing a SELECT COUNT(*) query if the collection hasn't been loaded and
+      # calling collection.size if it has. If it's more likely than not that the collection does have a size larger than zero
+      # and you need to fetch that collection afterwards, it'll take one less SELECT query if you use length.
+      def size
+        if @reflection.options[:cached]
+          result = @owner.send(:cache_read, @reflection)
+          return result.to_ary.size if result
+        end
+
+        if @owner.new_record? || (loaded? && !@reflection.options[:uniq])
+          @target.size
+        elsif !loaded? && !@reflection.options[:uniq] && @target.is_a?(Array)
+          unsaved_records = @target.select { |r| r.new_record? }
+          unsaved_records.size + count_records
+        else
+          count_records
+        end
+      end
+    end
+  end
+end

data/lib/activerecord/lib/active_record/associations/association_proxy.rb

@@ -0,0 +1,39 @@
+require 'set'
+
+module ActiveRecord
+  module Associations
+    class AssociationProxy
+      protected
+        def set_belongs_to_association_for(record)
+          reset_association_cache(record) if @reflection.options[:cached]
+
+          if @reflection.options[:as]
+            record["#{@reflection.options[:as]}_id"]   = @owner.id unless @owner.new_record?
+            record["#{@reflection.options[:as]}_type"] = @owner.class.base_class.name.to_s
+          else
+            record[@reflection.primary_key_name] = @owner.id unless @owner.new_record?
+          end
+        end
+
+      private
+        def reset_association_cache(record)
+          current_owner = current_owner(record)
+          return unless current_owner
+          current_owner.send(:cache_delete, @reflection)
+        end
+
+        def current_owner(record)
+          current_owner_id, current_owner_type = if @reflection.options[:as]
+            [ record["#{@reflection.options[:as]}_id"],
+               record["#{@reflection.options[:as]}_type"] ]
+          else
+            [ record[@reflection.primary_key_name],
+                @owner.class.base_class.name.to_s ]
+          end
+
+          return unless current_owner_id
+          current_owner_type.constantize.find(current_owner_id)
+        end
+    end
+  end
+end

data/lib/activerecord/lib/active_record/associations/has_many_association.rb

@@ -0,0 +1,7 @@
+module ActiveRecord
+  module Associations
+    class HasManyAssociation < AssociationCollection #:nodoc:
+      
+    end
+  end
+end