activerecord-collections 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 34ee535f77402404d36c364d9a78f8ee1d4d0dc8
+  data.tar.gz: 45d79d06830e4c8a90350bf26a953d75fb4f5f9c
+SHA512:
+  metadata.gz: 988fccfb23096549e3367a3e8518596d8ba5f362b9ebda32b32958390cfbac806b9c6879f9a294f9b053a2ab1a0a34aad824b99f19f5e3421ee4c8606c1fe4b4
+  data.tar.gz: 985765df3ed5f409d9b10a83546076a682422f2d9c9608442aed747b6af98ae32c6964e65adcc29c1426db16b64dd91ceae0c9e2bce178a538a5d933945fa114

data/lib/active_record/collection.rb

@@ -0,0 +1,54 @@
+module ActiveRecord
+  class Collection
+    include ActiveRecord::Collections::QueryChain
+    include ActiveRecord::Collections::Records
+    include ActiveRecord::Collections::Batching
+    include ActiveRecord::Collections::Delegation
+    include ActiveRecord::Collections::Serialization
+    attr_reader :model, :relation, :options
+
+    # dup relation and call none so that we don't end up inspecting it
+    # and loading it before we want it
+    def inspect
+      relation_backup = relation.dup
+      @records = @relation = relation.none
+      inspected = super
+      @records = @relation = relation_backup
+      inspected
+    end
+
+    protected
+
+    def initialize(model, *criteria)
+      @model = model
+      self.class.instance_eval do
+        model_plural = model.name.demodulize.pluralize.underscore
+        model_singular = model.name.demodulize.singularize.underscore
+        alias_method model_plural.to_sym, :records
+        alias_method "#{model_singular}_ids".to_sym, :record_ids
+        alias_method "on_#{model_plural}".to_sym, :on_records
+      end
+      @options = {} # defaults, not implemented yet
+      @options.merge!(criteria.extract_options!) if criteria.length > 1
+
+      if criteria.length == 1
+        criteria = criteria.first
+        if criteria.is_a?(ActiveRecord::Relation)
+          @relation = criteria
+        elsif criteria.is_a?(Hash) || criteria.is_a?(String) || criteria.is_a?(Array)
+          @relation = model.where(criteria).dup
+        end
+      else
+        @relation = model.where(criteria).dup
+      end
+    end
+
+    def initialize_copy(old)
+      @options = old.options.dup
+      @records = @relation = old.relation.dup
+      @total_records = old.total_records if !old.is_batch? && old.instance_variable_get(:@total_records).to_i > 0
+      page!(old.current_page).per!(old.per_page) if old.is_batch? || old.batched?(false)
+      is_batch! if old.is_batch?
+    end
+  end
+end

data/lib/active_record/collections/batching.rb

@@ -0,0 +1,245 @@
+module ActiveRecord
+  module Collections
+    module Batching
+      def self.included(base)
+        base.send :extend, ClassMethods
+      end
+
+      module ClassMethods
+        def default_batch_size(size=nil)
+          @default_batch_size = size unless size.nil?
+          @default_batch_size ||= 2_000
+        end
+
+        def batching_threshold(threshold=nil)
+          @batching_threshold = threshold unless threshold.nil?
+          @batching_threshold ||= 10_000
+        end
+
+        def batch_by_default!
+          @batch_by_default = true
+        end
+
+        def batch_by_default?
+          @batch_by_default || false
+        end
+
+        def page(*num)
+          new.page(*num)
+        end
+        alias_method :batch, :page
+
+        def per(num)
+          new.per(num)
+        end
+        alias_method :batch_size, :per
+      end
+
+      def default_batch_size
+        self.class.default_batch_size
+      end
+
+      def batching_threshold
+        self.class.batching_threshold
+      end
+
+      def batch_by_default?
+        self.class.batch_by_default?
+      end
+
+      def should_batch?(check_if_batched=true)
+        return false if is_batch?
+        return false if check_if_batched && batched?
+        batch_by_default? ||
+        ( batching_threshold > 0 &&
+          total_records >= batching_threshold )
+      end
+
+      def is_batch!
+        @is_batch = true
+        self
+      end
+
+      def is_batch?
+        @is_batch || false
+      end
+      alias_method :batch?, :is_batch?
+
+      def as_batch
+        dup.is_batch!
+      end
+
+      def as_next_batch
+        next_page!.as_batch
+      end
+
+      def to_batches
+        total_count # init count once before duping
+        batched = dup.batch!
+        batches = [batched.first_batch!.as_batch]
+        while batched.next_batch? do
+          batches << batched.next_batch!.as_batch
+        end
+        batches
+      end
+
+      def as_batches(&block)
+        total_count # init count once before duping
+        batched = dup.batch!
+        batches = [batched.first_batch!.as_batch]
+        yield batches.first if block_given?
+        while batched.next_batch? do
+          b = batched.next_batch!.as_batch
+          yield b if block_given?
+          batches << b
+        end
+        batches
+      end
+      alias_method :in_batches, :as_batches
+
+      def page(*num)
+        dup.page!(*num)
+      end
+      alias_method :batch, :page
+
+      def page!(*num)
+        reset!(false, false)
+        @page = num[0] || 1
+        @per ||= default_batch_size
+        @relation = relation.page(@page).per(@per)
+        self
+      end
+      alias_method :batch!, :page!
+
+      def per(num=nil)
+        dup.per!(num)
+      end
+      alias_method :batch_size, :per
+
+      def per!(num)
+        reset!(false, false)
+        @page ||= 1
+        @per = num
+        @relation = relation.page(@page).per(@per)
+        self
+      end
+      alias_method :batch_size!, :per!
+
+      def paginated?(check_if_should=false)
+        return true if !(@page.nil? && @per.nil?)
+        if check_if_should && should_batch?(false)
+          batch!
+          true
+        else
+          false
+        end
+      end
+      alias_method :batched?, :paginated?
+
+      def current_page
+        @page || 1
+      end
+      alias_method :current_batch, :current_page
+
+      def per_page
+        @per || total_count
+      end
+      alias_method :per_batch, :per_page
+
+      def total_pages
+        return 1 if is_batch?
+        (total_count.to_f / per_page.to_f).ceil
+      end
+      alias_method :total_batches, :total_pages
+
+      def each_page(&block)
+        if total_pages <= 1
+          yield to_a if block_given?
+          return [to_a]
+        end
+
+        first_page!
+        paged = []
+        total_pages.times do
+          paged << to_a
+          yield to_a if block_given?
+          next_page!
+        end
+        first_page!
+        paged
+      end
+      alias_method :each_batch, :each_page
+
+      def page_map(&block)
+        if total_pages <= 1
+          return (block_given? ? yield(to_a) : to_a)
+        end
+
+        first_page!
+        paged = []
+        total_pages.times do
+          paged << (block_given? ? yield(to_a) : to_a)
+          next_page!
+        end
+        first_page!
+        paged
+      end
+      alias_method :batch_map, :page_map
+
+      def flat_page_map(&block)
+        page_map(&block).flatten
+      end
+      alias_method :flat_batch_map, :flat_page_map
+
+      def first_page
+        dup.first_page!
+      end
+      alias_method :first_batch, :first_page
+
+      def first_page!
+        page!(1)
+      end
+      alias_method :first_batch!, :first_page!
+
+      def next_page?
+        current_page < total_pages
+      end
+      alias_method :next_batch?, :next_page?
+
+      def next_page
+        dup.next_page!
+      end
+      alias_method :next_batch, :next_page
+
+      def next_page!
+        page!(current_page + 1) if next_page?
+      end
+      alias_method :next_batch!, :next_page!
+
+      def prev_page?
+        current_page > 1
+      end
+      alias_method :prev_batch?, :prev_page?
+
+      def prev_page
+        dup.prev_page!
+      end
+      alias_method :prev_batch, :prev_page
+
+      def prev_page!
+        page!(current_page - 1) if prev_page?
+      end
+      alias_method :prev_batch!, :prev_page!
+
+      def last_page
+        dup.last_page!
+      end
+      alias_method :last_batch, :last_page
+
+      def last_page!
+        page!(total_pages)
+      end
+      alias_method :last_batch!, :last_page!
+    end
+  end
+end

data/lib/active_record/collections/delegation.rb

@@ -0,0 +1,91 @@
+module ActiveRecord
+  module Collections
+    module Delegation
+      def self.included(base)
+        base.send :extend, ClassMethods
+      end
+
+      module ClassMethods
+        def method_missing(meth, *args)
+          collection = new
+          return collection.send(meth, *args) if collection.respond_to?(meth)
+          super
+        end
+        
+        def respond_to_missing?(meth, include_private=false)
+          new.respond_to?(meth, include_private) || super
+        end
+      end
+
+      def method_missing(meth, *args)
+        if relation.respond_to?(meth)
+          return call_on_relation(meth, *args)
+        end
+
+        if records_respond_to?(meth)
+          return call_on_records(meth, *args)
+        end
+
+        super
+      end
+
+      def respond_to_missing?(meth, include_private=false)
+        records_respond_to?(meth, include_private) ||
+        relation.respond_to?(meth, include_private) ||
+        super
+      end
+
+      def on_relation(&block)
+        collection = dup
+        collection.instance_eval do
+          def self.method_missing(meth, *args)
+            call_on_relation(meth, *args)
+          end
+          def self.respond_to_missing?(meth, include_private=false)
+            relation.respond_to?(meth, include_private)
+          end
+        end
+        return collection.instance_eval(&block) if block_given?
+        collection
+      end
+
+      def on_records(&block)
+        collection = dup
+        collection.instance_eval do
+          def self.method_missing(meth, *args)
+            call_on_records(meth, *args)
+          end
+          def self.respond_to_missing?(meth, include_private=false)
+            records_respond_to?(meth, include_private)
+          end
+        end
+        return collection.instance_eval(&block) if block_given?
+        collection
+      end
+
+      protected
+
+      def call_on_records(meth, *args)
+        return page_map do |batch|
+          if model.columns.map(&:name).include?(meth.to_s) && !batch.loaded?
+            batch.pluck(meth)
+          else
+            batch.map { |record| record.send(meth, *args) }
+          end
+        end
+      end
+
+      def records_respond_to?(meth, include_private=false)
+        model.public_instance_methods.include?(meth) ||
+        (include_private && model.private_instance_methods.include?(meth)) ||
+        (!records.nil? && records.loaded? && records.first.respond_to?(meth, include_private))
+      end
+
+      def call_on_relation(meth, *args)
+        reset!
+        @relation = relation.send(meth, *args)
+        self
+      end
+    end
+  end
+end

data/lib/active_record/collections/query_chain.rb

@@ -0,0 +1,164 @@
+module ActiveRecord
+  module Collections
+    module QueryChain
+      def self.included(base)
+        base.send :extend, ClassMethods
+      end
+
+      module ClassMethods
+        def select(*args)
+          new.select(*args)
+        end
+
+        def distinct(bool=true)
+          new.distinct(bool)
+        end
+
+        def where(*args, &block)
+          new.where(*args, &block)
+        end
+
+        def order(*args, &block)
+          new.order(*args, &block)
+        end
+
+        def limit(*args, &block)
+          new.limit(*args, &block)
+        end
+
+        def joins(*args)
+          new.joins(*args)
+        end
+
+        def includes(*args)
+          new.includes(*args)
+        end
+
+        def references(*table_names)
+          new.references(*table_names)
+        end
+      end
+
+      def all
+        reset.limit!(nil)
+      end
+
+      def load
+        relation.load
+        records
+      end
+
+      def select(*args)
+        dup.select!(*args)
+      end
+
+      def select!(*args)
+        reset!
+        @relation = relation.select(*args)
+        self
+      end
+
+      def distinct(bool=true)
+        dup.distinct!(bool)
+      end
+
+      def distinct!(bool=true)
+        reset!
+        @relation = relation.distinct(bool)
+        self
+      end
+
+      def where(*args, &block)
+        dup.where!(*args, &block)
+      end
+
+      def where!(*args, &block)
+        reset!
+        relation.where!(*args, &block)
+        self
+      end
+
+      def not(*args, &block)
+        dup.not!(*args, &block)
+      end
+
+      def not!(*args, &block)
+        reset!
+        @relation = relation.where.not(*args, &block)
+        self
+      end
+
+      def or(*args, &block)
+        dup.or!(*args, &block)
+      end
+
+      def or!(*args, &block)
+        reset!
+        @relation = relation.or.where(*args, &block)
+        self
+      end
+
+      def order(*args, &block)
+        dup.order!(*args, &block)
+      end
+
+      def order!(*args, &block)
+        reset!(false)
+        relation.order!(*args, &block)
+        self
+      end
+
+      def limit(*args, &block)
+        dup.limit!(*args, &block)
+      end
+
+      def limit!(*args, &block)
+        reset!
+        relation.limit!(*args, &block)
+        self
+      end
+
+      def joins(*args)
+        dup.joins!(*args)
+      end
+
+      def joins!(*args)
+        reset!
+        relation.joins!(*args)
+        self
+      end
+
+      def includes(*args)
+        dup.includes!(*args)
+      end
+
+      def includes!(*args)
+        reset!
+        relation.includes!(*args)
+        self
+      end
+
+      def references(*table_names)
+        dup.references!(*table_names)
+      end
+
+      def references!(*table_names)
+        reset!
+        relation.references!(*table_names)
+        self
+      end
+
+      def reset(clear_total=true, clear_pages=true)
+        dup.reset!(clear_total, clear_pages)
+      end
+
+      def reset!(clear_total=true, clear_pages=true)
+        @records = @record_ids = @size = nil
+        @page = @per = nil if clear_pages
+        @total_records = nil if clear_total
+        relation.reset
+        self
+      end
+    end
+  end
+end

data/lib/active_record/collections/records.rb

@@ -0,0 +1,65 @@
+module ActiveRecord
+  module Collections
+    module Records
+      def records
+        @records ||= relation
+      end
+
+      def record_ids
+        @record_ids ||= records.loaded? ? records.map(&:id) : records.pluck(:id)
+      end
+
+      def pluck(col)
+        relation.pluck(col)
+      end
+
+      def to_ary
+        records.to_a
+      end
+      alias_method :to_a, :to_ary
+
+      def total_records
+        @total_records ||= relation.limit(nil).count
+      end
+
+      def total_count
+        #batch! if try(:should_batch?)
+        total_records
+      end
+      alias_method :total, :total_count
+      alias_method :count, :total_count
+
+      def size
+        @size ||= relation.size
+      end
+
+      def length
+        to_a.length
+      end
+
+      def each(&block)
+        batch! if try(:should_batch?)
+
+        if try(:batched?)
+          flat_batch_map.each { |record| block_given? ? yield(record) : record }
+        else
+          records.each { |record| block_given? ? yield(record) : record }
+        end
+      end
+
+      def map(&block)
+        batch! if try(:should_batch?)
+
+        if try(:batched?)
+          flat_batch_map.map { |record| block_given? ? yield(record) : record }
+        else
+          each.map { |record| block_given? ? yield(record) : record }
+        end
+      end
+
+      def flat_map(&block)
+        map(&block).flatten
+      end
+    end
+  end
+end

data/lib/active_record/collections/serialization.rb

@@ -0,0 +1,61 @@
+module ActiveRecord
+  module Collections
+    module Serialization
+      def self.included(base)
+        base.send :extend, ClassMethods
+      end
+
+      module ClassMethods
+        def from_json(json)
+          from_hash JSON.load(json)
+        end
+
+        def from_hash(hash)
+          hash.symbolize_keys!
+          collection = new
+          collection.select!(*hash[:select]) unless hash[:select].empty?
+          collection.distinct! if hash[:distinct] == true
+          collection.joins!(*hash[:joins]) unless hash[:joins].empty?
+          collection.references!(*hash[:references]) unless hash[:references].empty?
+          collection.includes!(*hash[:includes]) unless hash[:includes].empty?
+          collection.where!(*hash[:bind].map { |b| b[:value] }.unshift(hash[:where].join(" AND ").gsub(/\$\d/,'?'))) unless hash[:where].empty?
+          collection.order!(hash[:order]) unless hash[:order].empty?
+          collection.limit!(hash[:limit]) unless hash[:limit].empty?
+          collection.offset!(hash[:offset]) unless hash[:offset].empty?
+          collection
+        end
+      end
+
+      def to_sql
+        relation.to_sql
+      end
+
+      def to_hash(include_limit=false)
+        h = {
+          select:     relation.select_values,
+          distinct:   relation.distinct_value,
+          joins:      relation.joins_values,
+          references: relation.references_values,
+          includes:   relation.includes_values,
+          where:      relation.where_values.map { |v| v.is_a?(String) ? v : v.to_sql },
+          order:      relation.order_values.map { |v| v.is_a?(String) ? v : v.to_sql },
+          bind:       relation.bind_values.map { |b| {name: b.first.name, value: b.last} }
+        }
+        if include_limit || try(:is_batch?)
+          h[:limit] = relation.limit_value
+          h[:offset] = relation.offset_value
+        end
+        h
+      end
+      alias_method :to_h, :to_hash
+
+      def to_json(options=nil)
+        to_hash.to_json
+      end
+
+      def to_param
+        to_json
+      end
+    end
+  end
+end

data/lib/active_record/collections/version.rb

@@ -0,0 +1,5 @@
+module ActiveRecord
+  module Collections
+    VERSION = '0.0.2'
+  end
+end

data/lib/activerecord-collections.rb

@@ -0,0 +1,6 @@
+require 'active_record/collections/batching'
+require 'active_record/collections/delegation'
+require 'active_record/collections/query_chain'
+require 'active_record/collections/records'
+require 'active_record/collections/serialization'
+require 'active_record/collection'

data/spec/active_record/collection_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+RSpec.describe ActiveRecord::Collection do
+  context 'querying' do
+    before(:each) { create(:retailer) }
+
+    it 'should return 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
+  end
+
+  context 'batching' do
+    describe 'default_batch_size' do
+      it 'should default to 2000' do
+        expect(ActiveRecord::Collection.default_batch_size).to eql(2000)
+      end
+
+      it 'should be overridable by extending classes' do
+        expect(StockedProducts.default_batch_size).to eql(200)
+      end
+    end
+
+    describe 'batching_threshold' do
+      it 'should default to 10000' do
+        expect(ActiveRecord::Collection.batching_threshold).to eql(10000)
+      end
+
+      it 'should be overridable by extending classes' do
+        expect(StockedProducts.batching_threshold).to eql(500)
+      end
+    end
+  end
+end

data/spec/db/schema.rb

@@ -0,0 +1,23 @@
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :products do |t|
+    t.string :brand
+    t.string :name
+  end
+
+  create_table :retailers do |t|
+    t.string :name
+  end
+
+  create_table :stocked_products do |t|
+    t.integer :product_id
+    t.integer :retailer_id
+    t.integer :store_location_id
+    t.integer :stocked
+    t.float   :cost
+  end
+
+  create_table :store_locations do |t|
+    t.integer :retailer_id
+    t.string :address
+  end
+end

data/spec/factories/products.rb

@@ -0,0 +1,5 @@
+FactoryGirl.define do
+  factory :product do
+    name { Faker::Commerce.product_name }
+  end
+end

data/spec/factories/retailers.rb

@@ -0,0 +1,13 @@
+FactoryGirl.define do
+  factory :retailer do
+    name { Faker::Company.name }
+    after(:create) do |retailer, evaluator|
+      if Product.all.empty?
+        20.times { create(:product) }
+      end
+      5.times do
+        create(:store_location, retailer: retailer)
+      end
+    end
+  end
+end

data/spec/factories/stocked_products.rb

@@ -0,0 +1,9 @@
+FactoryGirl.define do
+  factory :stocked_product do
+    product
+    retailer
+    store_location
+    stocked { (0..50).to_a.sample }
+    cost { Faker::Commerce.price }
+  end
+end

data/spec/factories/store_locations.rb

@@ -0,0 +1,18 @@
+FactoryGirl.define do
+  factory :store_location do
+    retailer
+    address { [Faker::Address.street_address, Faker::Address.zip].join(" ") }
+    after(:create) do |location, evaluator|
+      products = Product.all
+      if products.empty?
+        20.times do
+          create(:stocked_product, store_location: location, retailer: location.retailer)
+        end
+      else
+        products.each do |product|
+          create(:stocked_product, store_location: location, retailer: location.retailer, product: product)
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,115 @@
+require 'active_record'
+require 'activerecord-collections'
+require 'factory_girl'
+require 'faker'
+require 'rspec'
+
+Dir[File.join(File.dirname(__FILE__), '..', "spec/support/**/*.rb")].each { |f| require f }
+Dir[File.join(File.dirname(__FILE__), '..', "spec/factories/**/*.rb")].each { |f| require f }
+
+RSpec.configure do |config|
+  config.before(:suite) do
+    ActiveRecord::Base.establish_connection adapter: "sqlite3", database: ":memory:"
+    capture_stdout { load "db/schema.rb" }
+    load 'support/models.rb'
+  end
+  
+  # Using Factory Girl instead of fixtures
+  config.include FactoryGirl::Syntax::Methods
+  # Lint your factories before running the suite to find any errors up front
+  config.before(:suite) do
+    ActiveRecord::Base.transaction do
+      begin
+        FactoryGirl.lint
+      rescue FactoryGirl::InvalidFactoryError => e
+        puts e.message
+      end
+      raise ActiveRecord::Rollback
+    end
+  end
+
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  #config.profile_examples = 10
+
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  #config.filter_run :focus
+  #config.run_all_when_everything_filtered = true
+end
+
+# TODO look into why I need to patch these to work with default behavior?
+class FalseClass
+  def false?
+    true
+  end
+
+  def true?
+    false
+  end
+end
+
+class TrueClass
+  def false?
+    false
+  end
+
+  def true?
+    true
+  end
+end

data/spec/support/capture_stdout.rb

@@ -0,0 +1,12 @@
+require 'stringio'
+ 
+module Kernel
+  def capture_stdout
+    out = StringIO.new
+    $stdout = out
+    yield
+    return out
+  ensure
+    $stdout = STDOUT
+  end
+end

data/spec/support/models.rb

@@ -0,0 +1,29 @@
+class Retailer < ActiveRecord::Base
+  has_many :stocked_products
+end
+
+class StoreLocation < ActiveRecord::Base
+  belongs_to :retailer
+  has_many :stocked_products
+end
+
+class Product < ActiveRecord::Base
+  has_many :stocked_products
+end
+
+class StockedProduct < ActiveRecord::Base
+  belongs_to :product
+  belongs_to :store_location
+  belongs_to :retailer
+end
+
+class StockedProducts < ActiveRecord::Collection
+  default_batch_size 200
+  batching_threshold 500
+
+  protected
+
+  def initialize(*criteria)
+    super(StockedProduct, *criteria)
+  end
+end

metadata

@@ -0,0 +1,156 @@
+--- !ruby/object:Gem::Specification
+name: activerecord-collections
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Mark Rebec
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: factory_girl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Create collections of records, represented by ActiveRecord::Relation
+  query criteria which can be serialized and passed around without executing queries
+  or loading records.
+email:
+- mark@markrebec.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/active_record/collection.rb
+- lib/active_record/collections/batching.rb
+- lib/active_record/collections/delegation.rb
+- lib/active_record/collections/query_chain.rb
+- lib/active_record/collections/records.rb
+- lib/active_record/collections/serialization.rb
+- lib/active_record/collections/version.rb
+- lib/activerecord-collections.rb
+- spec/active_record/collection_spec.rb
+- spec/db/schema.rb
+- spec/factories/products.rb
+- spec/factories/retailers.rb
+- spec/factories/stocked_products.rb
+- spec/factories/store_locations.rb
+- spec/spec_helper.rb
+- spec/support/capture_stdout.rb
+- spec/support/models.rb
+homepage: http://github.com/markrebec/activerecord-collections
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Create collections of records, represented by ActiveRecord::Relation query
+  criteria.
+test_files:
+- spec/active_record/collection_spec.rb
+- spec/db/schema.rb
+- spec/factories/products.rb
+- spec/factories/retailers.rb
+- spec/factories/stocked_products.rb
+- spec/factories/store_locations.rb
+- spec/spec_helper.rb
+- spec/support/capture_stdout.rb
+- spec/support/models.rb