active_collection 0.2.0

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Martin Emde
+
+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.rdoc

@@ -0,0 +1,8 @@
+= ActiveCollection
+
+Lazy-loaded Array-like collections of records.
+Compatible with will_paginate.
+
+== Copyright
+
+Copyright (c) 2009 Martin Emde. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,52 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "active_collection"
+    gem.summary = %Q{Lazy-loaded array of records}
+    gem.description = %Q{Lazy-loaded array of records}
+    gem.email = "martin.emde@gmail.com"
+    gem.homepage = "http://github.com/martinemde/active_collection"
+    gem.authors = ["Martin Emde"]
+    gem.add_development_dependency "rspec"
+    gem.rubyforge_project = "collection"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+  Jeweler::RubyforgeTasks.new do |rubyforge|
+    rubyforge.doc_task = "rdoc"
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "active_collection #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:major: 0
+:minor: 2
+:patch: 0

data/active_collection.gemspec

@@ -0,0 +1,62 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{active_collection}
+  s.version = "0.2.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Martin Emde"]
+  s.date = %q{2009-09-14}
+  s.description = %q{Lazy-loaded array of records}
+  s.email = %q{martin.emde@gmail.com}
+  s.extra_rdoc_files = [
+    "LICENSE",
+     "README.rdoc"
+  ]
+  s.files = [
+    ".document",
+     ".gitignore",
+     "LICENSE",
+     "README.rdoc",
+     "Rakefile",
+     "VERSION.yml",
+     "active_collection.gemspec",
+     "lib/active_collection.rb",
+     "lib/active_collection/base.rb",
+     "lib/active_collection/includes.rb",
+     "lib/active_collection/order.rb",
+     "lib/active_collection/pagination.rb",
+     "lib/active_collection/scope.rb",
+     "spec/active_collection_spec.rb",
+     "spec/pagination_spec.rb",
+     "spec/spec.opts",
+     "spec/spec_helper.rb"
+  ]
+  s.homepage = %q{http://github.com/martinemde/active_collection}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{collection}
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Lazy-loaded array of records}
+  s.test_files = [
+    "spec/active_collection_spec.rb",
+     "spec/pagination_spec.rb",
+     "spec/spec_helper.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<rspec>, [">= 0"])
+    else
+      s.add_dependency(%q<rspec>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<rspec>, [">= 0"])
+  end
+end

data/lib/active_collection.rb

@@ -0,0 +1,14 @@
+activesupport_path = "#{File.dirname(__FILE__)}/../../activesupport/lib"
+$:.unshift(activesupport_path) if File.directory?(activesupport_path)
+require 'active_support'
+
+module ActiveCollection
+  autoload :Base, 'active_collection/base'
+  autoload :Scope, 'active_collection/scope'
+  autoload :Order, 'active_collection/order'
+  autoload :Includes, 'active_collection/includes'
+  autoload :Pagination, 'active_collection/pagination'
+
+  Base
+end
+

data/lib/active_collection/base.rb

@@ -0,0 +1,213 @@
+# Lazy-loaded collection of records
+# Behaves like an Array or Hash (where bang methods alter self)
+module ActiveCollection
+  # Raised when a mutating method is called on an already loaded collection.
+  class AlreadyLoadedError < StandardError #:nodoc:
+  end
+
+  class Base
+    #instance_methods.each do |m|
+    #  unless m =~ /(^__|^proxy_)/ || %w[should should_not nil? send dup extend inspect object_id].include?(m)
+    #    undef_method m
+    #  end
+    #end
+    
+    include Enumerable
+
+    attr_reader :params
+
+    # Create a Collection by passing the important query params from
+    # the controller.
+    #
+    # Example:
+    #
+    #     BeerCollection.new(params.only("q","page"))
+    #
+    # If any :page parameter is passed, nil or not, the assumption will be that
+    # the collection should be a paged collection and the current_page will
+    # default to 1.
+    def initialize(params = {})
+      @params = params.symbolize_keys
+    end
+
+    alias_method :proxy_respond_to?, :respond_to?
+
+    # Does the ActiveCollection or it's target collection respond to method?
+    def respond_to?(*args)
+      proxy_respond_to?(*args) || collection.respond_to?(*args)
+    end
+
+    def self.model_class
+      @model_class ||= name.sub(/Collection$/,'').constantize
+    end
+
+    def model_class
+      self.class.model_class
+    end
+
+    def self.table_name
+      model_class.table_name
+    end
+
+    def table_name
+      self.class.table_name
+    end
+
+    def self.human_name
+      table_name.gsub(/_/,' ')
+    end
+
+    def human_name
+      self.class.human_name
+    end
+
+    # Forwards <tt>===</tt> explicitly to the collection because the instance method
+    # removal above doesn't catch it. Loads the collection if needed.
+    def ===(other)
+      other === collection
+    end
+
+    def send(method, *args)
+      if proxy_respond_to?(method)
+        super
+      else
+        collection.send(method, *args)
+      end
+    end
+
+    # Turn the params into a hash suitable for passing the collection directly as an arg to a named path.
+    def to_param
+      params.empty?? nil : params.to_param
+    end
+
+    def as_data_hash
+      data_hash = { "collection" => collection.as_json }
+      data_hash["total_entries"] = total_entries
+      data_hash
+    end
+
+    def to_xml(options = {})
+      collect
+      options[:indent] ||= 2
+      xml = options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
+      xml.instruct! unless options[:skip_instruct]
+      xml.tag!(table_name) do
+        xml.total_entries(total_entries, :type => "integer")
+        xml.collection(:type => "array") do
+          collection.each do |item|
+            item.to_xml(:indent => options[:indent], :builder => xml, :skip_instruct => true)
+          end
+        end
+      end
+    end
+
+    def as_json(options = nil)
+      {table_name => as_data_hash}.as_json(options)
+    end
+
+    # Implements Enumerable
+    def each(&block)
+      collection.each(&block)
+    end
+
+    # Grab the raw collection.
+    def all
+      collection
+    end
+
+    # The emptiness of the collection (limited by query and pagination)
+    def empty?
+      size.zero?
+    end
+
+    # The size of the collection (limited by query and pagination)
+    #
+    # It will avoid using a count query if the collection is already loaded.
+    def size
+      loaded?? collection.size : total_entries
+    end
+
+    # Always returns the total count regardless of pagination.
+    def total_entries
+      @total_entries ||= load_count
+    end
+
+    # The size of the collection (limited by query and pagination)
+    #
+    # Similar to ActiveRecord associations, length will always load the collection.
+    def length
+      collection.size
+    end
+
+    # true if the collection data has been loaded
+    def loaded?
+      !!@collection
+    end
+
+    protected
+
+    # Pass methods on to the collection.
+    def method_missing(method, *args)
+      if Array.method_defined?(method) && !Object.method_defined?(method)
+        raise "#{method} received with #{args.join(', ')}"
+        if block_given?
+          collection.send(method, *args)  { |*block_args| yield(*block_args) }
+        else
+          collection.send(method, *args)
+        end
+      else
+        super
+        #message = "undefined method `#{method.to_s}' for \"#{collection}\":#{collection.class.to_s}"
+        #raise NoMethodError, message
+      end
+    end
+
+    # The actual collection data. Must be memoized or you'll access data over
+    # and over and over again.
+    def collection
+      @collection ||= load_collection
+    end
+
+    # Overload this method to add extra find options.
+    #
+    # :offset and :limit will be overwritten by the pagination_options if the
+    # collection is paginated, because you shouldn't be changing the paging
+    # directly if you're working with a paginated collection
+    # 
+    def query_options
+      {}
+    end
+
+    def load_count
+      model_class.count(count_options)
+    end
+
+    # Overload this method to change the way the collection is loaded.
+    def load_collection
+      model_class.all(find_options)
+    end
+
+    # Raises an AlreadyLoadedError if the collection has already been loaded
+    def raise_if_loaded
+      raise AlreadyLoadedError, "Cannot modify a collection that has already been loaded." if loaded?
+    end
+
+    # Extracted from AR:B
+    # Object#to_a is deprecated, though it does have the desired behavior
+    def safe_to_array(o)
+      case o
+      when NilClass
+        []
+      when Array
+        o
+      else
+        [o]
+      end
+    end
+  end
+
+  Base.class_eval do
+    include Scope
+    include Includes, Order, Pagination
+  end
+end

data/lib/active_collection/includes.rb

@@ -0,0 +1,56 @@
+module ActiveCollection
+  module Includes
+
+    def self.included(mod)
+      mod.extend ClassMethods
+      mod.class_eval do
+        find_scope :include_options
+      end
+    end
+
+    module ClassMethods
+      def includes(*includes)
+        write_inheritable_attribute(:default_includes, includes)
+      end
+
+      def default_includes
+        read_inheritable_attribute(:default_includes) || []
+      end
+    end
+
+    def includes
+      @includes = self.class.default_includes
+    end
+
+    def include(*includes)
+      ac = dup
+      ac.include! *includes
+      ac
+    end
+
+    def include!(*includes)
+      raise_if_loaded
+      @includes = (safe_to_array(includes) + safe_to_array(includes)).uniq
+    end
+
+    def include_options
+      @includes.blank?? {} : { :include => @includes }
+    end
+
+    protected
+
+    # Taken from ActiveRecord::Base
+    #
+    # Object#to_a is deprecated, though it does have the desired behavior
+    def safe_to_array(o)
+      case o
+      when NilClass
+        []
+      when Array
+        o
+      else
+        [o]
+      end
+    end
+  end
+end

data/lib/active_collection/order.rb

@@ -0,0 +1,40 @@
+module ActiveCollection
+  module Order
+
+    def self.included(mod)
+      mod.extend ClassMethods
+      mod.class_eval do
+        find_scope :order_options
+      end
+    end
+
+    def order
+      @order ||= self.class.default_order
+    end
+
+    def order_by(order)
+      ac = dup
+      ac.order_by! order
+      ac
+    end
+
+    def order_by!(order)
+      raise_if_loaded
+      @order = order
+    end
+
+    def order_options
+      order ? { :order => order } : {}
+    end
+
+    module ClassMethods
+      def order_by(order = "id ASC")
+        write_inheritable_attribute(:default_order, order)
+      end
+
+      def default_order
+        read_inheritable_attribute(:default_order) || nil
+      end
+    end
+  end
+end

data/lib/active_collection/pagination.rb

@@ -0,0 +1,189 @@
+module ActiveCollection
+  module Pagination
+    PER_PAGE = 30
+
+    def self.included(mod)
+      mod.extend ClassMethods
+
+      mod.class_eval do
+        alias_method_chain :total_entries, :pagination
+        alias_method_chain :size, :pagination
+        find_scope :pagination_options
+      end
+    end
+
+    module ClassMethods
+      def per_page
+        PER_PAGE
+      end
+    end
+
+    def current_page
+      @current_page ||= params.has_key?(:page) ? (params[:page] || 1).to_i : nil
+    end
+
+    # Defaults to the model class' per_page.
+    def per_page
+      @per_page ||= params[:per_page] || (model_class.respond_to?(:per_page) && model_class.per_page) || self.class.per_page
+    end
+    attr_writer :per_page
+
+    # Loads total entries and calculates the size from that.
+    def size_with_pagination
+      if paginated?
+        last_page?? size_without_pagination % per_page : per_page
+      else
+        size_without_pagination
+      end
+    end
+
+    # Create a new collection for the page specified
+    #
+    # Optionally accepts a per page parameter which will override the default
+    # per_page for the new collection (without changing the current collection).
+    def page(pg, per = self.per_page)
+      new_collection = self.class.new(params.merge(:page => pg))
+      new_collection.per_page = per
+      new_collection
+    end
+
+    # Force this collection to a page specified
+    #
+    # Optionally accepts a per page parameter which will override the per_page
+    # for this collection.
+    def page!(pg, per = self.per_page)
+      raise_if_loaded
+      @per_page = per
+      @current_page = pg
+    end
+
+    # Helper method that is true when someone tries to fetch a page with a
+    # larger number than the last page. Can be used in combination with flashes
+    # and redirecting.
+    # 
+    # loads total_entries if not already loaded.
+    def out_of_bounds?
+      current_page > total_pages
+    end
+
+    # Current offset of the paginated collection. If we're on the first page,
+    # it is always 0. If we're on the 2nd page and there are 30 entries per page,
+    # the offset is 30. This property is useful if you want to render ordinals
+    # side by side with records in the view: simply start with offset + 1.
+    # 
+    # loads total_entries if not already loaded.
+    def offset
+      (current_page - 1) * per_page
+    end
+
+    # current_page - 1 or nil if there is no previous page.
+    def previous_page
+      current_page > 1 ? (current_page - 1) : nil
+    end
+
+    # current_page + 1 or nil if there is no next page.
+    # 
+    # loads total_entries if not already loaded.
+    def next_page
+      current_page < total_pages ? (current_page + 1) : nil
+    end
+
+    # true if the collection is the last page.
+    # 
+    # may load total_entries if not already loaded.
+    def last_page?
+      next_page.nil?
+    end
+
+    # New Collection for current_page - 1 or nil.
+    def previous_page_collection
+      previous_page ? page(previous_page, per_page) : nil
+    end
+
+    # New Collection for current_page + 1 or nil
+    # 
+    # loads total_entries if not already loaded.
+    def next_page_collection
+      next_page ? page(next_page, per_page) : nil
+    end
+
+    # Always returns the total count regardless of pagination.
+    #
+    # Attempts to save a count query if collection is loaded and is the last page.
+    def total_entries_with_pagination
+      @total_entries ||=
+        if paginated? 
+          if loaded? and length < per_page and (current_page == 1 or length > 0)
+            offset + length
+          else
+            total_entries_without_pagination
+          end
+        else
+          total_entries_without_pagination
+        end
+    end
+
+    # Total number of pages.
+    def total_pages
+      @total_pages ||= (total_entries / per_page.to_f).ceil
+    end
+
+    # return a paginated collection if it isn't already paginated.
+    # returns self if already paginated.
+    def paginate
+      paginated?? self : page(current_page || 1)
+    end
+
+    # forces pagination of self, raising if already loaded.
+    # returns current_page if the collection is now paginated
+    # returns nil if already paginated
+    def paginate!
+      raise_if_loaded
+      current_page ? nil : @current_page = 1
+    end
+
+    # if the collection has a page parameter
+    def paginated?
+      current_page && current_page > 0
+    end
+
+    def as_data_hash
+      data_hash = { "collection" => collection.as_json }
+      if paginated?
+        data_hash["total_entries"] = total_entries
+        data_hash["page"] = current_page
+        data_hash["per_page"] = per_page
+        data_hash["total_pages"] = total_pages
+      end
+      data_hash
+    end
+
+    def to_xml(options = {})
+      collect
+      options[:indent] ||= 2
+      xml = options[:builder] ||= Builder::XmlMarkup.new(:indent => options[:indent])
+      xml.instruct! unless options[:skip_instruct]
+      xml.tag!(table_name) do
+        if paginated?
+          xml.total_entries(total_entries, :type => "integer")
+          xml.page(current_page, :type => "integer")
+          xml.per_page(per_page, :type => "integer")
+          xml.total_pages(total_pages, :type => "integer")
+        end
+        xml.collection(:type => "array") do
+          collection.each do |item|
+            item.to_xml(:indent => options[:indent], :builder => xml, :skip_instruct => true)
+          end
+        end
+      end
+    end
+
+    protected
+
+    # Find options for pagination.
+    def pagination_options
+      paginated?? { :offset => offset, :limit => per_page } : {}
+    end
+
+  end
+end

data/lib/active_collection/scope.rb

@@ -0,0 +1,95 @@
+require 'active_support/core_ext/array/extract_options'
+
+module ActiveCollection
+  module Scope
+    #extend ActiveSupport::Concern
+
+    def self.included(mod)
+      mod.extend ClassMethods
+    end
+
+    # Find options for loading the collection.
+    #
+    # To add more options, define a method that returns a hash with the
+    # additional options for find and then add it like this:
+    #
+    #   class BeerCollection
+    #     find_scope :awesome_beer_only
+    #
+    #     def awesome_beer_only
+    #       { :conditions => "beer = 'awesome'" }
+    #     end
+    #   end
+    #
+    def find_options
+      self.class.scope_for_find.to_options(self)
+    end
+
+    # Count options for loading the total count.
+    #
+    # To add more options, define a method that returns a hash with the
+    # additional options for count and then add it like this:
+    #
+    #   class BeerCollection
+    #     count_scope :awesome_beer_only
+    #
+    #     def awesome_beer_only
+    #       { :conditions => "beer = 'awesome'" }
+    #     end
+    #   end
+    #
+    def count_options
+      self.class.scope_for_count.to_options(self)
+    end
+
+    module ClassMethods
+      def scope_for_find
+        ScopeBuilder.new(scope_builder + find_scope_builder)
+      end
+
+      def scope_for_count
+        ScopeBuilder.new(scope_builder + count_scope_builder)
+      end
+
+      [:scope, :find_scope, :count_scope].each do |scope|
+        module_eval <<-SCOPE, __FILE__, __LINE__
+          def #{scope}(*methods, &block)
+            #{scope} = ScopeBuilder.build(:#{scope}, *methods, &block)
+            @#{scope}_builder ||= ScopeBuilder.new
+            @#{scope}_builder.concat #{scope}
+          end
+
+          def #{scope}_builder
+            @#{scope}_builder ||= ScopeBuilder.new
+            if superclass.respond_to?(:#{scope}_builder)
+              superclass.#{scope}_builder + @#{scope}_builder
+            else
+              @#{scope}_builder
+            end
+          end
+        SCOPE
+      end
+    end
+
+    class ScopeBuilder < Array
+      def self.build(kind, *methods, &block)
+        methods, options = extract_options(*methods, &block)
+        methods.map! { |method| ActiveSupport::Callbacks::Callback.new(kind, method, options) }
+        new(methods)
+      end
+
+      def to_options(object)
+        inject({}) { |h, callback| h.merge( callback.call(object) ) }
+      end
+
+      private
+        def self.extract_options(*methods, &block)
+          methods.flatten!
+          options = methods.extract_options!
+          methods << block if block_given?
+          return methods, options
+        end
+    end
+  end
+end
+

data/spec/active_collection_spec.rb

@@ -0,0 +1,109 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+class BeerCollection < ActiveCollection::Base
+end
+
+class Beer
+end
+
+describe ActiveCollection do
+  subject { BeerCollection.new }
+
+  context "(empty)" do
+    describe "(count methods)" do
+      before do
+        Beer.stub!(:count).and_return(0)
+      end
+
+      it "is empty" do
+        subject.should be_empty
+      end
+
+      it "has size of 0" do
+        subject.size.should == 0
+      end
+    end
+
+    describe "(collection loading methods)" do
+      before do
+        Beer.stub!(:all).and_return([])
+      end
+
+      it "has length of 0" do
+        subject.length.should == 0
+      end
+
+      it "doesn't load count after loading the collection" do
+        subject.length
+        Beer.should_not_receive(:count)
+        subject.should be_empty
+      end
+
+      it "doesn't load count after loading the collection" do
+        subject.length
+        Beer.should_not_receive(:count)
+        subject.size.should == 0
+      end
+
+      it "yields no items on each" do
+        count = 0
+        subject.each { |i| count += 1 }
+        count.should == 0
+      end
+    end
+  end
+
+  context "(simple collection with 5 records)" do
+    def records
+      @records ||= begin
+                     beers = []
+                     5.times { beers << Beer.new }
+                     beers
+                   end
+    end
+
+    describe "(count methods)" do
+      before { Beer.stub!(:count).and_return(records.size) }
+
+      it "is not empty" do
+        subject.should_not be_empty
+      end
+
+      it "has a size of 5" do
+        subject.size.should == 5
+      end
+
+      it "has total_entries of 5" do
+        subject.total_entries.should == 5
+      end
+    end
+
+    describe "(collection loading methods)" do
+      before do
+        Beer.stub!(:all).and_return(records)
+      end
+
+      it "has length of 5" do
+        subject.length.should == 5
+      end
+
+      it "doesn't load count after loading the collection" do
+        subject.length
+        Beer.should_not_receive(:count)
+        subject.should_not be_empty
+      end
+
+      it "doesn't load count after loading the collection" do
+        subject.length
+        Beer.should_not_receive(:count)
+        subject.size.should == 5
+      end
+
+      it "yields 5 items to each" do
+        count = 0
+        subject.each { |i| count += 1 }
+        count.should == 5
+      end
+    end
+  end
+end

data/spec/pagination_spec.rb

@@ -0,0 +1,311 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+class BeerCollection < ActiveCollection::Base
+end
+
+class Beer
+end
+
+describe "an empty collection", :shared => true do
+  it "is empty" do
+    subject.should be_empty
+  end
+
+  it "has 0 total entries" do
+    subject.total_entries.should == 0
+  end
+
+  it "has 0 total_pages" do
+    subject.total_pages.should == 0
+  end
+
+  it "has length of 0" do
+    subject.length.should == 0
+  end
+
+  it "yields no items on each" do
+    count = 0
+    subject.each { |i| count += 1 }
+    count.should == 0
+  end
+end
+
+describe ActiveCollection do
+  subject { BeerCollection.new(:page => 1) }
+
+  context "(empty)" do
+    before do
+      Beer.stub!(:count).and_return(0)
+      Beer.stub!(:all).and_return([])
+    end
+
+    describe "(page 1)" do
+      it_should_behave_like "an empty collection"
+
+      it "is on page 1" do
+        subject.current_page.should == 1
+      end
+    end
+
+    describe "(page 2)" do
+      subject { BeerCollection.new(:page => 2) }
+
+      it_should_behave_like "an empty collection"
+
+      it "should be out of bounds" do
+        subject.should be_out_of_bounds
+      end
+
+      it "is on page 2" do
+        subject.current_page.should == 2
+      end
+    end
+  end
+
+  context "(simple collection with 5 records)" do
+    def records
+      @records ||= begin
+                     beers = []
+                     5.times { beers << Beer.new }
+                     beers
+                   end
+    end
+    before { Beer.stub!(:count).and_return(records.size) }
+
+    describe "(default per_page)" do
+      before do
+        Beer.stub!(:all).with(
+          :limit => ActiveCollection::Base.per_page,
+          :offset => 0
+        ).and_return(records)
+      end
+
+      describe "(page 1)" do
+        it "is not empty" do
+          subject.should_not be_empty
+        end
+
+        it "has a size of 5" do
+          subject.size.should == 5
+        end
+
+        it "has total_entries of 5" do
+          subject.total_entries.should == 5
+        end
+
+        it "has length of 5" do
+          subject.length.should == 5
+        end
+
+        it "doesn't load count after loading the collection" do
+          subject.length
+          Beer.should_not_receive(:count)
+          subject.empty?
+          subject.size
+          subject.total_entries
+        end
+
+        it "yields 5 items to each" do
+          count = 0
+          subject.each { |i| count += 1 }
+          count.should == 5
+        end
+
+        it "has 1 total pages" do
+          subject.total_pages.should == 1
+        end
+
+        it "is on page 1" do
+          subject.current_page.should == 1
+        end
+
+        it "is the last page" do
+          subject.should be_last_page
+        end
+
+        it "has no next page" do
+          subject.next_page.should be_nil
+        end
+
+        it "has no previous page" do
+          subject.previous_page.should be_nil
+        end
+
+        it "returs nil next page collection" do
+          subject.next_page_collection.should be_nil
+        end
+
+        it "returs nil previous page collection" do
+          subject.previous_page_collection.should be_nil
+        end
+
+        it "has default per_page" do
+          subject.per_page.should == ActiveCollection::Base.per_page
+        end
+
+        it "is not out of bounds" do
+          subject.should_not be_out_of_bounds
+        end
+
+        it "has a 0 offset" do
+          subject.offset.should == 0
+        end
+
+        it "loads records using default limit and 0 offset" do
+          Beer.should_receive(:all).with(:limit => ActiveCollection::Base.per_page, :offset => 0).and_return(records)
+          subject.length
+        end
+      end
+    end
+
+    context "(2 per page)" do
+      describe "(page 1)" do
+        before { Beer.stub!(:all).with(:limit => 2, :offset => 0).and_return(records[0..1]) }
+        subject { BeerCollection.new(:page => 1, :per_page => 2) }
+
+        it "is not empty" do
+          subject.should_not be_empty
+        end
+
+        it "has a size of 2" do
+          subject.size.should == 2
+        end
+
+        it "has a length of 2" do
+          subject.length.should == 2
+        end
+
+        it "has 5 total entries" do
+          subject.total_entries.should == 5
+        end
+
+        it "has 3 total pages" do
+          subject.total_pages.should == 3
+        end
+
+        it "is on page 1" do
+          subject.current_page.should == 1
+        end
+
+        it "is not the last page" do
+          subject.should_not be_last_page
+        end
+
+        it "has next page of 2" do
+          subject.next_page.should == 2
+        end
+
+        it "has no previous page" do
+          subject.previous_page.should be_nil
+        end
+
+        it "returs a next page collection for page 2" do
+          nex = subject.next_page_collection
+          nex.should_not be_nil
+          nex.current_page.should == 2
+        end
+
+        it "returs nil previous page collection" do
+          subject.previous_page_collection.should be_nil
+        end
+
+        it "has per_page of 2" do
+          subject.per_page.should == 2
+        end
+
+        it "is not out of bounds" do
+          subject.should_not be_out_of_bounds
+        end
+
+        it "has a 0 offset" do
+          subject.offset.should == 0
+        end
+
+        it "calls count to find total_entries even when collection is loaded" do
+          subject.length
+          Beer.should_receive(:count).and_return(5)
+          subject.total_entries.should == 5
+        end
+
+        it "loads records using default limit and 0 offset" do
+          Beer.should_receive(:all).with(:limit => 2, :offset => 0).and_return(records)
+          subject.length
+        end
+      end
+
+      describe "(page 3)" do
+        before { Beer.stub!(:all).with(:limit => 2, :offset => 4).and_return(records[4..4]) }
+        subject { BeerCollection.new(:page => 3, :per_page => 2) }
+
+        it "is not empty" do
+          subject.should_not be_empty
+        end
+
+        it "has a size of 1" do
+          subject.size.should == 1
+        end
+
+        it "has a length of 1" do
+          subject.length.should == 1
+        end
+
+        it "has 5 total entries" do
+          subject.total_entries.should == 5
+        end
+
+        it "has 3 total pages" do
+          subject.total_pages.should == 3
+        end
+
+        it "is on page 3" do
+          subject.current_page.should == 3
+        end
+
+        it "is the last page" do
+          subject.should be_last_page
+        end
+
+        it "has no next page" do
+          subject.next_page.should be_nil
+        end
+
+        it "has previous page of 2" do
+          subject.previous_page.should == 2
+        end
+
+        it "returs nil next page collection" do
+          subject.next_page_collection.should be_nil
+        end
+
+        it "returs nil previous page collection" do
+          prev = subject.previous_page_collection
+          prev.should_not be_nil
+          prev.current_page.should == 2
+        end
+
+        it "has per_page of 2" do
+          subject.per_page.should == 2
+        end
+
+        it "is not out of bounds" do
+          subject.should_not be_out_of_bounds
+        end
+
+        it "has a 0 offset" do
+          subject.offset.should == 4
+        end
+
+        it "does not call count to find total_entries when collection is loaded" do
+          subject.length
+          Beer.should_not_receive(:count).and_return(5)
+          subject.total_entries.should == 5
+        end
+
+        it "loads records using default limit and 0 offset" do
+          Beer.should_receive(:all).with(:limit => 2, :offset => 4).and_return(records)
+          subject.length
+        end
+      end
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--format progress
+--loadby mtime
+--reverse

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'rubygems'
+require 'active_collection'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification 
+name: active_collection
+version: !ruby/object:Gem::Version 
+  version: 0.2.0
+platform: ruby
+authors: 
+- Martin Emde
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-09-14 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: Lazy-loaded array of records
+email: martin.emde@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION.yml
+- active_collection.gemspec
+- lib/active_collection.rb
+- lib/active_collection/base.rb
+- lib/active_collection/includes.rb
+- lib/active_collection/order.rb
+- lib/active_collection/pagination.rb
+- lib/active_collection/scope.rb
+- spec/active_collection_spec.rb
+- spec/pagination_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/martinemde/active_collection
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: collection
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Lazy-loaded array of records
+test_files: 
+- spec/active_collection_spec.rb
+- spec/pagination_spec.rb
+- spec/spec_helper.rb