ar_attr_lazy 0.1.0

data/.gitignore

@@ -0,0 +1,3 @@
+.DS_Store
+*.gem
+*.tmproj

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Elliot Winkler
+
+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,35 @@
+# ar_attr_lazy
+
+## Summary
+
+A little gem for Rails that provides the ability to specify attributes that will not be loaded when the record is loaded from the database, until you explicitly refer to those attributes. This is useful when you have a lot of text columns in your table; in this case lazy-loading the text attributes is a good way to lend your server a hand and cut down on database access time.
+
+## Installation/Usage
+
+First:
+
+1. Run `gem install ar_attr_lazy` (probably as root)
+2. Add `config.gem 'ar_attr_lazy'` to environment.rb
+3. Optionally run `rake gems:unpack` to vendor the gem
+
+Then, simply add an `attr_lazy` line to your model, listing the attributes you want lazy-loaded. For instance:
+
+    class Post < ActiveRecord::Base
+      attr_lazy :body
+    end
+  
+Now when you do a `find`, instead of doing a `SELECT *`, it does e.g. `SELECT id, permalink, title, created_at, updated_at`, and only when you say `post.body` will it pull the `body` column.
+
+## Support
+
+If you find a bug or have a feature request, I want to know about it! Feel free to file a [Github issue](http://github.com/mcmire/ar_attr_lazy/issues), or do one better and fork the [project on Github](http://github.com/mcmire/ar_attr_lazy) and send me a pull request or patch. Be sure to add tests if you do so, though.
+
+You can also [email me](mailto:elliot.winkler@gmail.com), or [find me on Twitter](http://twitter.com/mcmire).
+
+## Inspiration
+
+<http://refactormycode.com/codes/219-activerecord-lazy-attribute-loading-plugin-for-rails>
+
+## Author/License
+
+(c) 2009-2010 Elliot Winkler. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,62 @@
+require 'rubygems'
+require 'rake'
+
+require File.dirname(__FILE__) + "/lib/mcmire/ar_attr_lazy/version"
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.version = Mcmire::ArAttrLazy::VERSION
+    gem.name = "ar_attr_lazy"
+    gem.summary = %Q{Rails gem that provides lazy-loading for attributes.}
+    gem.description = %Q{A little gem for Rails that provides the ability to specify attributes that will not be loaded when the record is loaded from the database, until you explicitly refer to those attributes. This is useful when you have a lot of text columns in your table; in this case lazy-loading the text attributes is a good way to lend your server a hand and cut down on database access time.}
+    gem.email = "elliot.winkler@gmail.com"
+    gem.homepage = "http://github.com/mcmire/ar_attr_lazy"
+    gem.authors = ["Elliot Winkler"]
+    unless ENV["AR_VERSION"]
+      gem.add_dependency "activerecord", "< 3.0"
+    end
+    gem.add_development_dependency "mcmire-protest"
+    gem.add_development_dependency "mcmire-matchy"
+    gem.add_development_dependency "mcmire-mocha"
+    gem.add_development_dependency "mocha-protest-integration"
+    #gem.add_development_dependency "yard", ">= 0"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => [:check_dependencies, :"check_dependencies:development"]
+
+task :default => :test
+
+begin
+  require 'yard'
+  YARD::Rake::YardocTask.new
+rescue LoadError
+  task :yardoc do
+    abort "YARD is not available. In order to run yardoc, you must: sudo gem install yard"
+  end
+end

data/init.rb

@@ -0,0 +1 @@
+require 'mcmire/ar_attr_lazy'

data/lib/mcmire/ar_attr_lazy.rb

@@ -0,0 +1,32 @@
+module Mcmire
+  module ArAttrLazy
+    class Version
+      include Comparable
+      
+      def initialize(version_string)
+        @major, @minor, @tiny = split(version_string)
+      end
+      
+      def <=>(other_version_string)
+        [@major, @minor, @tiny] <=> split(other_version_string)
+      end
+      
+    private
+      def split(version_string)
+        pieces = version_string.to_s.split(".")
+        (0..2).map {|i| pieces[i].to_i || 0 }
+      end
+    end
+    
+    def self.ar_version
+      @ar_version ||= Version.new(ActiveRecord::VERSION)
+    end
+  end
+end
+
+require 'mcmire/ar_attr_lazy/base_ext'
+require 'mcmire/ar_attr_lazy/association_preload_ext'
+require 'mcmire/ar_attr_lazy/habtm_ext'
+require 'mcmire/ar_attr_lazy/join_base_ext'
+require 'mcmire/ar_attr_lazy/belongs_to_association_ext'
+require 'mcmire/ar_attr_lazy/has_many_through_association_ext'

data/lib/mcmire/ar_attr_lazy/association_preload_ext.rb

@@ -0,0 +1,55 @@
+module Mcmire
+  module ArAttrLazy
+    module AssociationPreloadExt
+      def self.included(includer)
+        includer.alias_method_chain :find_associated_records, :attr_lazy
+      end
+      
+      #def preload_one_association(records, association, preload_options={})
+      #  class_to_reflection = {}
+      #  records.group_by {|record| class_to_reflection[record.class] ||= record.class.reflections[association]}.each do |reflection, records|
+      #    raise ConfigurationError, "Association named '#{ association }' was not found; perhaps you misspelled it?" unless reflection
+      #    # Add the unlazy columns as the default :select option (overrideable with an explicit select)
+      #    if record = records[0] and record.class.respond_to?(:unlazy_column_list)
+      #      preload_options[:select] = record.class.unlazy_column_list
+      #    end
+      #    send("preload_#{reflection.macro}_association", records, reflection, preload_options)
+      #  end
+      #end
+      
+      def find_associated_records_with_attr_lazy(ids, reflection, preload_options)
+        # Add the unlazy columns as the default :select option (overrideable with an explicit select)
+        preload_options[:select] = reflection.klass.unlazy_column_list if reflection.klass.respond_to?(:unlazy_column_list)
+        find_associated_records_without_attr_lazy(ids, reflection, preload_options)
+      end
+    end
+  end
+end
+
+ActiveRecord::AssociationPreload::ClassMethods.class_eval do
+  include Mcmire::ArAttrLazy::AssociationPreloadExt
+  
+  # Unfortunately we can't override this using a module...
+  def preload_has_and_belongs_to_many_association(records, reflection, preload_options={})
+    table_name = reflection.klass.quoted_table_name
+    id_to_record_map, ids = construct_id_map(records)
+    records.each {|record| record.send(reflection.name).loaded}
+    options = reflection.options
+
+    conditions = "t0.#{reflection.primary_key_name} #{in_or_equals_for_ids(ids)}"
+    conditions << append_conditions(reflection, preload_options)
+
+    associated_records = reflection.klass.with_exclusive_scope do
+      # Select unlazy_column_list by default
+      select = options[:select]
+      select ||= reflection.klass.unlazy_column_list if reflection.klass.respond_to?(:unlazy_column_list)
+      select ||= table_name+'.*'
+      reflection.klass.find(:all, :conditions => [conditions, ids],
+        :include => options[:include],
+        :joins => "INNER JOIN #{connection.quote_table_name options[:join_table]} t0 ON #{reflection.klass.quoted_table_name}.#{reflection.klass.primary_key} = t0.#{reflection.association_foreign_key}",
+        :select => "#{select}, t0.#{reflection.primary_key_name} as the_parent_record_id",
+        :order => options[:order])
+    end
+    set_association_collection_records(id_to_record_map, reflection.name, associated_records, 'the_parent_record_id')
+  end
+end

data/lib/mcmire/ar_attr_lazy/base_ext.rb

@@ -0,0 +1,69 @@
+module Mcmire
+  module ArAttrLazy
+    module BaseExt
+      module ClassMethods
+        def unlazy_column_names
+          column_names - attr_lazy_columns
+        end
+      
+        def unlazy_column_list
+          unlazy_column_names.map {|c| "#{quoted_table_name}.#{connection.quote_column_name(c)}" }.join(",")
+        end
+
+        def find_with_attr_lazy(*args)
+          # don't limit :select clause if there aren't any lazy attributes defined on this model
+          # or we're inside a scope right now that has already defined :select
+          if attr_lazy_columns.empty? or (scope = scope(:find) and scope[:select])
+            find_without_attr_lazy(*args)
+          else
+            with_scope(:find => { :select => unlazy_column_list }) do
+              find_without_attr_lazy(*args)
+            end
+          end
+        end
+        
+        def read_lazy_attribute(record, attr)
+          # we use with_exclusive_scope here to override any :includes that may have happened in a parent scope
+          select = [primary_key, attr].map {|c| "#{quoted_table_name}.#{connection.quote_column_name(c)}" }.join(",")
+          with_exclusive_scope(:find => { :select => select }) do
+            find_without_attr_lazy(record[primary_key])[attr]
+          end
+        end
+      end
+      
+      module InstanceMethods
+      private
+        def read_lazy_attribute(attr)
+          attr = attr.to_s
+          unless @attributes.include?(attr)
+            @attributes[attr] = self.class.read_lazy_attribute(self, attr)
+          end
+          @attributes[attr]
+        end
+      end
+    
+      module MacroMethods
+        def attr_lazy(*args)
+          include InstanceMethods
+          extend ClassMethods
+          class_inheritable_accessor :attr_lazy_columns
+          write_inheritable_attribute :attr_lazy_columns, []
+          (class << self; self; end).class_eval do
+            alias_method_chain :find, :attr_lazy
+          end
+          
+          args = [args].flatten.map(&:to_s)
+          new_cols = args - (attr_lazy_columns & args)
+          write_inheritable_attribute(:attr_lazy_columns, attr_lazy_columns | args)
+          new_cols.each do |col|
+            class_eval("def #{col}; read_lazy_attribute :#{col}; end", __FILE__, __LINE__)
+          end
+        end
+      end
+    end
+  end
+end
+
+ActiveRecord::Base.class_eval do
+  extend Mcmire::ArAttrLazy::BaseExt::MacroMethods
+end

data/lib/mcmire/ar_attr_lazy/belongs_to_association_ext.rb

@@ -0,0 +1,19 @@
+ActiveRecord::Associations::BelongsToAssociation.class_eval do
+  # Unfortunately we can't override this using a module...
+  def find_target
+    find_method = if @reflection.options[:primary_key]
+                    "find_by_#{@reflection.options[:primary_key]}"
+                  else
+                    "find"
+                  end
+    # Select unlazy_column_list by default
+    select = @reflection.klass.unlazy_column_list if @reflection.klass.respond_to?(:unlazy_column_list)
+    @reflection.klass.send(find_method,
+      @owner[@reflection.primary_key_name],
+      :select     => select || @reflection.options[:select],
+      :conditions => conditions,
+      :include    => @reflection.options[:include],
+      :readonly   => @reflection.options[:readonly]
+    ) if @owner[@reflection.primary_key_name]
+  end
+end

data/lib/mcmire/ar_attr_lazy/habtm_ext.rb

@@ -0,0 +1,23 @@
+module Mcmire
+  module ArAttrLazy
+    module HabtmExt
+      def self.included(includer)
+        includer.instance_eval do
+          alias_method_chain :construct_find_options!, :attr_lazy
+        end
+      end
+    
+      def construct_find_options_with_attr_lazy!(options)
+        # Select unlazy_column_list by default
+        options[:select] ||= @reflection.options[:select]
+        options[:select] ||= @reflection.klass.unlazy_column_list if @reflection.klass.respond_to?(:unlazy_column_list)
+        options[:select] ||= '*'
+        construct_find_options_without_attr_lazy!(options)
+      end
+    end
+  end
+end
+
+ActiveRecord::Associations::HasAndBelongsToManyAssociation.class_eval do
+  include Mcmire::ArAttrLazy::HabtmExt
+end

data/lib/mcmire/ar_attr_lazy/has_many_through_association_ext.rb

@@ -0,0 +1,9 @@
+ActiveRecord::Associations::HasManyThroughAssociation.class_eval do
+  # Unfortunately we can't override this using a module...
+  def construct_select(custom_select = nil)
+    distinct = "DISTINCT " if @reflection.options[:uniq]
+    default_select = @reflection.klass.unlazy_column_list if @reflection.klass.respond_to?(:unlazy_column_list)
+    default_select ||= "#{@reflection.quoted_table_name}.*"
+    selected = custom_select || @reflection.options[:select] || "#{distinct}#{default_select}"
+  end
+end

data/lib/mcmire/ar_attr_lazy/join_base_ext.rb

@@ -0,0 +1,14 @@
+ActiveRecord::Associations::ClassMethods::JoinDependency::JoinBase.class_eval do
+  # Unfortunately we can't override this using a module...
+  def column_names_with_alias
+    unless defined?(@column_names_with_alias)
+      @column_names_with_alias = []
+      # Use unlazy_column_names instead of just column_names
+      column_names = active_record.respond_to?(:unlazy_column_names) ? active_record.unlazy_column_names : active_record.column_names
+      ([active_record.primary_key] + (column_names - [active_record.primary_key])).each_with_index do |column_name, i|
+        @column_names_with_alias << [column_name, "#{ aliased_prefix }_r#{ i }"]
+      end
+    end
+    @column_names_with_alias
+  end
+end

data/lib/mcmire/ar_attr_lazy/version.rb

@@ -0,0 +1,5 @@
+module Mcmire
+  module ArAttrLazy
+    VERSION = "0.1.0"
+  end
+end

data/test/factories.rb

@@ -0,0 +1,96 @@
+class FactoryMaker
+  class << self
+    attr_accessor :factories
+  
+    # make(klass)
+    # make(klass, factory)
+    # make(klass, factory, custom_attributes)
+    def make(*args, &block)
+      factorize(:new, args, &block)
+    end
+    
+    # make!(klass)
+    # make!(klass, factory)
+    # make!(klass, factory, custom_attributes)
+    def make!(*args, &block)
+      factorize(:create!, args, &block)
+    end
+    
+    def attributes(factory)
+      attributes = FactoryMaker.factories[factory]
+      raise "Couldn't find factory \"#{factory}\"" unless attributes
+      attributes
+    end
+    
+  private
+    def factorize(method, args, &block)
+      custom_attributes = args.extract_options!
+      klass, factory = args
+      factory ||= klass.to_s.underscore.to_sym
+      attributes = self.attributes(factory)
+      model = klass.send(method, attributes.merge(custom_attributes))
+      yield(model) if block_given?
+      model
+    end
+  end
+end
+
+class ActiveRecord::Base
+  class << self
+    # make
+    # make(factory)
+    # make(factory, custom_attributes)
+    def make(*args, &block)
+      factorize(:make, args, &block)
+    end
+  
+    # make!
+    # make!(factory)
+    # make!(factory, custom_attributes)
+    def make!(*args, &block)
+      factorize(:make!, args, &block)
+    end
+    
+  private
+    def factorize(method, args, &block)
+      custom_attributes = args.extract_options!
+      factory = args.first
+      FactoryMaker.send(method, self, factory, custom_attributes, &block)
+    end
+  end
+end
+
+FactoryMaker.factories = {
+  :account => {
+    :name => "Joe's Account"
+  },
+  :user => {
+    :name => "Joe Bloe",
+    :login => "joe",
+    :password => "secret",
+    :email => "joe@bloe.com",
+    :bio => "It's hip to be square!"
+  },
+  :avatar => {
+    :filename => "somefile.png",
+    :data => "10101010010010001000101"
+  },
+  :post => {
+    :title => "The Best Post",
+    :permalink => 'the-best-post',
+    :body => "This is the best post, ya hear?? Word.",
+    :summary => "T i t b p, y h?? W."
+  },
+  :comment => {
+    :name => "A douchebag",
+    :body => "Your site suxx0rsss"
+  },
+  :tag => {
+    :name => "Foo",
+    :description => "The description and stuff"
+  },
+  :category => {
+    :name => "zing",
+    :description => "Hey hey hey hey I don't like your girlfriend"
+  }
+}