collection_extensions 0.0.1 → 1.0.0

data/.travis.yml

@@ -1,10 +1,6 @@
 language: ruby
 rvm:
-  - 1.8.7
   - 1.9.2
   - 1.9.3
-  - jruby-18mode
   - jruby-19mode
-  - rbx-18mode
   - rbx-19mode
-  - ree

data/Gemfile

@@ -3,6 +3,8 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in collection_extensions.gemspec
 gemspec
 
+gem 'activerecord', '~> 3.2'
+
 group :test do
   gem "rake", "~> 0.9.2"
   gem 'rspec', '~> 2.11.0'

data/README.md

@@ -1,7 +1,8 @@
 # CollectionExtensions
 
 Sometimes an operation just doesn't fit well into a scope, but you don't want to lose your declarative code style
-by operating on all the objects individually. This gem adds a few lines of code to make it easier to add methods to collections of objects.
+by operating on all the objects individually. This gem adds a few lines of code to make it easier to add methods
+to collections of ActiveRecord objects.
 
 <img src="https://secure.travis-ci.org/arches/collection_extensions.png" />
 
@@ -9,44 +10,56 @@ by operating on all the objects individually. This gem adds a few lines of code
 
 Add this line to your application's Gemfile:
 
-    gem 'collection_extensions'
+```ruby
+gem 'collection_extensions'
+```
 
 And then execute:
 
-    $ bundle
+```bash
+$ bundle
+```
 
 Or install it yourself as:
 
-    $ gem install collection_extensions
+```bash
+$ gem install collection_extensions
+```
 
 ## Usage
 
-Include the module in your model and specify what collections you want to extend:
+A collections of records will be extended based on the naming convention `%sCollectionExtensions`, where the `%s` substitution
+is the camel-cased name of the class. For example, collections of User objects will be extended with the methods in the
+`UserCollectionExtensions` model and collections of BlogPost objects will be extended with the methods in the `BlogPostCollectionExtensions`
+module.
 
-    class User < ActiveRecord::Base
-        include CollectionExtensions
-        has_many :orders, :preferences
-        extend_collections :orders, :preferences
-        
-        # the original unextended collection is still available, aliased as orig_* (eg, orig_orders or orig_preferences)
-    end
-
-This will use the modules OrdersCollectionExtensions and PreferencesCollectionExtensions to extend those associations
-whenever you use them. For example:
+```ruby
+module BlogPostCollectionExtensions
 
-    module OrdersCollectionExtensions
-      def for_product_id(product_id)
-        # 'self' is the array of orders
-        select {|o| o.line_items.collect(&:product_id).include? product_id}
+  # hash key is user ID, hash value is the number of comments they've posted on this set of blog posts
+  def comments_per_user
+    comment_counts = {}
+    
+    # 'self' is the array of blog posts
+    each do |blog_post|
+      blog_post.comments.each do |comment|
+        comment_counts[comment.user_id] ||= 0
+        comment_counts[comment.user_id] += 1
       end
     end
     
-    > User.find(1).orders.for_product_id(2)
+    comment_counts
+  end
+end
+```
 
-If you want a different naming convention, set the config variable using `%s` string substitution:
+### Naming Convention
 
-    CollectionExtensions::Config.naming_convention = "MethodsForCollectionsOf%s"
+If you want a different naming convention, set the config variable using `%s` string substitution:
 
+```ruby
+CollectionExtensions::Config.naming_convention = "MethodsForCollectionsOf%s"
+```
 
 ## Contributing
 

data/lib/collection_extensions.rb

@@ -1,25 +1,32 @@
 require "collection_extensions/version"
 require "collection_extensions/cattr"
 require "collection_extensions/config"
+require "active_record"
 
-module CollectionExtensions
+class ActiveRecord::Relation
+  alias :orig_to_a :to_a
+  alias :orig_method_missing :method_missing
 
-  def self.included(base)
-    base.extend ClassMethods
-  end
+  def to_a
+    records = orig_to_a
+
+    records.extend extension_module if extension_module
 
-  module ClassMethods
-    def extend_collections(*associations)
-      Array(associations).each do |association|
-        alias_method "orig_#{association}", association
+    records
+  end
 
-        define_method association do
-          upper_camel = association.to_s.split("_").collect{|piece| piece.capitalize}.join
-          extender = Object.const_get(CollectionExtensions::Config.naming_convention % upper_camel)
-          send("orig_#{association}").extend(extender)
-        end
-      end
+  def extension_module
+    extension_klass = CollectionExtensions::Config.naming_convention % @klass.to_s
+    if Object.constants.include? extension_klass.to_sym
+      Object.const_get(extension_klass)
     end
   end
 
+  def method_missing(method, *args, &block)
+    if extension_module and extension_module.method_defined? method
+      to_a.send(method, *args, &block)
+    else
+      orig_method_missing(method, *args, &block)
+    end
+  end
 end

data/lib/collection_extensions/version.rb

@@ -1,3 +1,3 @@
 module CollectionExtensions
-  VERSION = "0.0.1"
+  VERSION = "1.0.0"
 end

data/spec/collection_extensions_spec.rb

@@ -1,69 +1,67 @@
+require 'active_record'
 require 'collection_extensions'
 
-module ExamplesCollectionExtensions
-  def operate_on_all_examples
-    "operate_on_all_examples"
+module UserCollectionExtensions
+  def utest
+    "ufoo"
   end
 end
 
-module FoobarsCollectionExtensions
-  def operate_on_all_foobars
-    "operate_on_all_foobars"
-  end
+module ExtensionMethodsForUserCollections
 end
 
-module MethodsForCollectionsOfExamples
-  def operate_on_all_examples
-    "from a module with a different naming convention"
-  end
-end
-
-class CollectionTester
-  include CollectionExtensions
-
-  def examples
-    "original examples method"
+describe "#extension_class" do
+  context "when the extension module exists" do
+    it "returns the constant" do
+      r = ActiveRecord::Relation.new :User, :users
+      r.extension_module.should == UserCollectionExtensions
+    end
   end
 
-  def foobars
-    "original foobars method"
+  context "when the extension module doesn't exist" do
+    it "returns nil" do
+      r = ActiveRecord::Relation.new :Order, :orders
+      r.extension_module.should be_nil
+    end
   end
 
-  extend_collections :examples, :foobars
-end
-
-describe CollectionExtensions do
-  let(:ct) { CollectionTester.new }
+  context "when the naming convention has been changed" do
+    before { CollectionExtensions::Config.naming_convention = "ExtensionMethodsForUserCollections" }
+    after { CollectionExtensions::Config.naming_convention = CollectionExtensions::Config::DEFAULT_NAMING_CONVENTION }
 
-  describe "#extend_collections" do
-    it "aliases the examples" do
-      ct.orig_examples.should == "original examples method"
-      ct.examples.should be_a ExamplesCollectionExtensions
-      ct.examples.operate_on_all_examples.should == "operate_on_all_examples"
-    end
-
-    it "aliases the foobars" do
-      ct.orig_foobars.should == "original foobars method"
-      ct.foobars.should be_a FoobarsCollectionExtensions
-      ct.foobars.operate_on_all_foobars.should == "operate_on_all_foobars"
+    it "uses the proper convention to return the constant" do
+      r = ActiveRecord::Relation.new :User, :users
+      r.extension_module.should == ExtensionMethodsForUserCollections
     end
   end
 end
 
-describe "changing the naming convention" do
-  let(:ct) { CollectionTester.new }
-
-  before do
-    CollectionTester::Config.naming_convention = "MethodsForCollectionsOf%s"
+describe "calling methods on the array" do
+  it "pulls extension methods from the module" do
+    r = ActiveRecord::Relation.new :User, :users
+    r.stub(orig_to_a: [])
+    r.to_a.utest.should == "ufoo"
   end
+end
 
-  it "extends the association with the proper module" do
-    ct.orig_examples.should == "original examples method"
-    ct.examples.should be_a MethodsForCollectionsOfExamples
-    ct.examples.operate_on_all_examples.should == "from a module with a different naming convention"
+describe "calling methods on the relation" do
+  it "pulls extension methods from the module" do
+    r = ActiveRecord::Relation.new :User, :users
+    r.stub(orig_to_a: [])
+    r.utest.should == "ufoo"
   end
-end
 
-describe "" do
+  it "lets non-extension methods pass through" do
+    r = ActiveRecord::Relation.new :User, :users
+    r.stub(orig_to_a: ['first'])
+    r.first.should == 'first'
+  end
 
+  context "when the extension module doesn't exist" do
+    it "lets methods pass through" do
+      r = ActiveRecord::Relation.new :Order, :orders
+      r.stub(orig_to_a: ['first'])
+      r.first.should == 'first'
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: collection_extensions
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-04 00:00:00.000000000 Z
+date: 2012-09-05 00:00:00.000000000Z
 dependencies: []
 description: Lightweight framework for adding methods to groups of ActiveRecord objects
 email: