activerecord-collections 0.0.23 → 0.0.24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 192790cbc51085d35ee324b7c2e61936c56285ed
-  data.tar.gz: 500efab14683ba051367ea4bcfa72757e8ba4761
+  metadata.gz: f6a1d8087898abadc4007581ab714424b15e797d
+  data.tar.gz: 4bd38a8e29b7e491e37b9337b7ee88d6c61042a0
 SHA512:
-  metadata.gz: 8cc2ca473a2f4d6ccee65824c69940ace08445dfdb4ff36b174f3fbbd591f153d5d3eebe72ec6bf3cb532aa51fcaac2522034342b313d00ea1a5c30d6a615076
-  data.tar.gz: 1f71fdfa21ecc5ab76419307eb2a23301d26cef231fbe08618c5d29e36f8bb09035eb27877b8b8ab637b120f7142d7e1611814c3cd5bfe99a6fdf32c64009b06
+  metadata.gz: 7a3a224370a7e042c1d1a184db1e38b70e0c93cd1614b1a5ad090d04b585218c9c2bd3a52e553f1432186a558cddcca062a2d119baa34e16e1df62c57090d921
+  data.tar.gz: 39574217740a6c075d46f413232d50020bdeb17a35c2ec88d0a03a0bd3710ce1ddfce0cf7d0bc03c241600e2bad99a0101b08f8c7347d583106165724c87cc72

data/lib/active_record/collection.rb

@@ -12,30 +12,41 @@ module ActiveRecord
     COLLECTIONS = []
 
     class << self
-      attr_reader :collections
       def inherited(subclass)
-        ActiveRecord::Collection::COLLECTIONS << subclass
+        ActiveRecord::Collection::COLLECTIONS << subclass.name unless ActiveRecord::Collection::COLLECTIONS.include?(subclass.name)
+        # if parent class is not Collection, register the collectable on the class as the closest parent's collectable
+      end
+
+      def collections
+        ActiveRecord::Collection::COLLECTIONS.map(&:constantize)
       end
 
       def collectable(klass=nil)
         unless klass.nil?
           raise ArgumentError, "The collection model must inherit from ActiveRecord::Base" unless klass.ancestors.include?(ActiveRecord::Base)
-          ActiveRecord::Collection::COLLECTABLES[name] ||= klass
+          ActiveRecord::Collection::COLLECTABLES[name] ||= klass.name
         end
 
         if ActiveRecord::Collection::COLLECTABLES[name].nil?
-          begin
-            klass = self.name.demodulize.singularize.constantize
-            ActiveRecord::Collection::COLLECTABLES[name] = klass if !klass.nil? && klass.ancestors.include?(ActiveRecord::Base)
-          rescue
-            # singularized class doesn't exist
-          end
+          klass = infer_collectable
+          ActiveRecord::Collection::COLLECTABLES[name] = klass.name if !klass.nil? && klass.ancestors.include?(ActiveRecord::Base)
         end
 
         raise "Unable to determine a model to use for your collection, please set one with the `collectable` class method" if ActiveRecord::Collection::COLLECTABLES[name].nil? # TODO implement real exceptions
-        ActiveRecord::Collection::COLLECTABLES[name]
+
+        ActiveRecord::Collection::COLLECTABLES[name].constantize
       end
       alias_method :model, :collectable
+
+      def infer_collectable(klass=self)
+        singular = klass.name.demodulize.singularize
+        raise "Cannot infer collectable from singular collection" if singular == klass.name.demodulize
+        singular.constantize
+      rescue
+        parent = klass.ancestors[1]
+        return nil if parent.name == 'ActiveRecord::Collection'
+        parent.try(:collectable) || infer_collectable(parent)
+      end
     end
 
     def collectable

data/lib/active_record/collections/serialization.rb

@@ -24,7 +24,13 @@ module ActiveRecord
           collection.includes!(*hash[:includes]) unless hash[:includes].empty?
 
           wheres = hash[:where].partition { |w| w.is_a?(Hash) }
-          wheres.first.each { |wh| collection.where!(wh) }
+          wheres.first.each do |wh|
+            if wh.keys.first == :not
+              collection.not!(wh[:not])
+            else
+              collection.where!(wh)
+            end
+          end
           collection.where!(*hash[:bind].map { |b| b[:value] }.unshift(wheres.last.join(" AND ").gsub(/\$\d/,'?'))) unless wheres.last.empty?
 
           collection.group!(hash[:group]) unless hash[:group].empty?

data/lib/active_record/collections/serializer.rb

@@ -123,6 +123,9 @@ module ActiveRecord
             serialize_node(node.expr)
           when Arel::Nodes::And
             node.children.map { |child| serialize_node(child) }
+          when Arel::Nodes::NotEqual
+            bound = bind.delete_at(bind.find_index { |b| b[:name] == node.left.name.to_s })[:value]
+            {not: {node.left.name.to_sym => bound}}
           when Arel::Nodes::Or
             {or: [serialize_node(node.left), serialize_node(node.right)]}
           else

data/lib/active_record/collections/version.rb

@@ -1,5 +1,5 @@
 module ActiveRecord
   module Collections
-    VERSION = '0.0.23'
+    VERSION = '0.0.24'
   end
 end

data/spec/active_record/collection_spec.rb

@@ -2,36 +2,95 @@ require 'spec_helper'
 
 RSpec.describe ActiveRecord::Collection do
   context 'querying' do
-    before(:each) { create(:retailer) }
+    before(:each) { 5.times { create(:retailer) } }
 
-    it 'should return the same records as a standard relation' do
+    it 'returns the same records as a standard relation' do
       retailer = Retailer.all.to_a.sample
       collection = StockedProducts.where(retailer_id: retailer.id)
       relation = StockedProduct.where(retailer_id: retailer.id)
       expect(collection.count).to eql(relation.count)
       expect(collection.pluck(:id).sort).to eql(relation.pluck(:id).sort)
     end
+
+    describe 'not' do
+      it 'excludes records matching the criteria' do
+      retailer = Retailer.all.to_a.sample
+      collection = StockedProducts.not(retailer_id: retailer.id)
+      relation = StockedProduct.where.not(retailer_id: retailer.id)
+      expect(collection.count).to eql(relation.count)
+      expect(collection.pluck(:id).sort).to eql(relation.pluck(:id).sort)
+      end
+    end
+
+    describe 'to_collection' do
+      it 'reproduces the same result set' do
+        retailer = Retailer.all.to_a.sample
+        product = retailer.stocked_products.sample.product
+        relation = StockedProduct.where.not(retailer_id: retailer.id)
+        collection = StockedProduct.where.not(retailer_id: retailer.id).to_collection
+        expect(collection.count).to eql(relation.count)
+        expect(collection.pluck(:id).sort).to eql(relation.pluck(:id).sort)
+      end
+
+      it 'supports multiple parameters' do
+        retailer = Retailer.all.to_a.sample
+        product = retailer.stocked_products.sample.product
+        relation = StockedProduct.where.not(retailer_id: retailer.id, product_id: product.id)
+        collection = StockedProduct.where.not(retailer_id: retailer.id, product_id: product.id).to_collection
+        expect(collection.count).to eql(relation.count)
+        expect(collection.pluck(:id).sort).to eql(relation.pluck(:id).sort)
+      end
+    end
   end
 
   context 'batching' do
     describe 'default_batch_size' do
-      it 'should default to 500' do
+      it 'defaults to 500' do
         expect(ActiveRecord::Collection.default_batch_size).to eql(500)
       end
 
-      it 'should be overridable by extending classes' do
+      it 'is overridable by extending classes' do
         expect(StockedProducts.default_batch_size).to eql(200)
       end
     end
 
     describe 'batching_threshold' do
-      it 'should default to 0' do
+      it 'defaults to 0' do
         expect(ActiveRecord::Collection.batching_threshold).to eql(0)
       end
 
-      it 'should be overridable by extending classes' do
+      it 'is overridable by extending classes' do
         expect(StockedProducts.batching_threshold).to eql(500)
       end
     end
   end
+
+  context 'subclassing' do
+    it 'infers the collectable from the class name' do
+      expect(Retailers.collectable).to eql(Retailer)
+    end
+
+    it 'allows setting a collectable' do
+      expect(ProductCollection.collectable).to eql(Product)
+    end
+
+    context 'multiple collections for the same model' do
+      it 'registers all of them as collections for the model' do
+        expect(ActiveRecord::Collection::COLLECTABLES[StockedProducts.name]).to eql('StockedProduct')
+        expect(ActiveRecord::Collection::COLLECTABLES[StockedProductCollection.name]).to eql('StockedProduct')
+      end
+    end
+
+    context 'a subclass' do
+      it 'registers itself as a collection' do
+        expect(ActiveRecord::Collection.collections).to include(ProductCollection)
+        expect(ActiveRecord::Collection.collections).to include(AnotherProductCollection)
+      end
+
+      it 'inherits the parent collectable' do
+        expect(AnotherProductCollection.collectable).to eql(Product)
+        expect(MoreRetailers.collectable).to eql(Retailer)
+      end
+    end
+  end
 end

data/spec/support/models.rb

@@ -21,3 +21,20 @@ class StockedProducts < ActiveRecord::Collection
   default_batch_size 200
   batching_threshold 500
 end
+
+class StockedProductCollection < ActiveRecord::Collection
+  collectable StockedProduct
+end
+
+class ProductCollection < ActiveRecord::Collection
+  collectable Product
+end
+
+class AnotherProductCollection < ProductCollection
+end
+
+class Retailers < ActiveRecord::Collection
+end
+
+class MoreRetailers < Retailers
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: activerecord-collections
 version: !ruby/object:Gem::Version
-  version: 0.0.23
+  version: 0.0.24
 platform: ruby
 authors:
 - Mark Rebec
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-22 00:00:00.000000000 Z
+date: 2015-04-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord