railscart 0.0.1

data/starter-app/vendor/plugins/paginating_find/test_app/app/controllers/application.rb

@@ -0,0 +1,2 @@
+class ApplicationController < ActionController::Base
+end

data/starter-app/vendor/plugins/paginating_find/test_app/config/boot.rb

@@ -0,0 +1,44 @@
+# Don't change this file. Configuration is done in config/environment.rb and config/environments/*.rb
+
+unless defined?(RAILS_ROOT)
+  root_path = File.join(File.dirname(__FILE__), '..')
+
+  unless RUBY_PLATFORM =~ /mswin32/
+    require 'pathname'
+    root_path = Pathname.new(root_path).cleanpath(true).to_s
+  end
+
+  RAILS_ROOT = root_path
+end
+
+unless defined?(Rails::Initializer)
+  if File.directory?("#{RAILS_ROOT}/vendor/rails")
+    require "#{RAILS_ROOT}/vendor/rails/railties/lib/initializer"
+  else
+    require 'rubygems'
+
+    environment_without_comments = IO.readlines(File.dirname(__FILE__) + '/environment.rb').reject { |l| l =~ /^#/ }.join
+    environment_without_comments =~ /[^#]RAILS_GEM_VERSION = '([\d.]+)'/
+    rails_gem_version = $1
+
+    if version = defined?(RAILS_GEM_VERSION) ? RAILS_GEM_VERSION : rails_gem_version
+      rails_gem = Gem.cache.search('rails', "=#{version}").first
+
+      if rails_gem
+        gem "rails", "=#{version}"
+        require rails_gem.full_gem_path + '/lib/initializer'
+      else
+        STDERR.puts %(Cannot find gem for Rails =#{version}:
+    Install the missing gem with 'gem install -v=#{version} rails', or
+    change environment.rb to define RAILS_GEM_VERSION with your desired version.
+  )
+        exit 1
+      end
+    else
+      gem "rails"
+      require 'initializer'
+    end
+  end
+
+  Rails::Initializer.run(:set_load_path)
+end

data/starter-app/vendor/plugins/paginating_find/test_app/config/database.yml

@@ -0,0 +1,6 @@
+test:
+  adapter: mysql
+  database: paginating_find_test
+  username: root
+  password:
+  host: localhost

data/starter-app/vendor/plugins/paginating_find/test_app/config/environment.rb

@@ -0,0 +1,53 @@
+# Be sure to restart your web server when you modify this file.
+
+# Uncomment below to force Rails into production mode when 
+# you don't control web/app server and can't set it the proper way
+# ENV['RAILS_ENV'] ||= 'production'
+
+# Specifies gem version of Rails to use when vendor/rails is not present
+RAILS_GEM_VERSION = '1.2.3'
+
+# Bootstrap the Rails environment, frameworks, and default configuration
+require File.join(File.dirname(__FILE__), 'boot')
+
+Rails::Initializer.run do |config|
+  # Settings in config/environments/* take precedence those specified here
+  
+  # Skip frameworks you're not going to use (only works if using vendor/rails)
+  # config.frameworks -= [ :action_web_service, :action_mailer ]
+
+  # Add additional load paths for your own custom dirs
+  # config.load_paths += %W( #{RAILS_ROOT}/extras )
+
+  # Force all environments to use the same logger level 
+  # (by default production uses :info, the others :debug)
+  # config.log_level = :debug
+
+  # Use the database for sessions instead of the file system
+  # (create the session table with 'rake db:sessions:create')
+  # config.action_controller.session_store = :active_record_store
+
+  # Use SQL instead of Active Record's schema dumper when creating the test database.
+  # This is necessary if your schema can't be completely dumped by the schema dumper, 
+  # like if you have constraints or database-specific column types
+  # config.active_record.schema_format = :sql
+
+  # Activate observers that should always be running
+  # config.active_record.observers = :cacher, :garbage_collector
+
+  # Make Active Record use UTC-base instead of local time
+  # config.active_record.default_timezone = :utc
+  
+  # See Rails::Configuration for more options
+end
+
+# Add new inflection rules using the following format 
+# (all these examples are active by default):
+# Inflector.inflections do |inflect|
+#   inflect.plural /^(ox)$/i, '\1en'
+#   inflect.singular /^(ox)en/i, '\1'
+#   inflect.irregular 'person', 'people'
+#   inflect.uncountable %w( fish sheep )
+# end
+
+# Include your application configuration below

data/starter-app/vendor/plugins/paginating_find/test_app/config/environments/test.rb

@@ -0,0 +1,19 @@
+# Settings specified here will take precedence over those in config/environment.rb
+
+# The test environment is used exclusively to run your application's
+# test suite.  You never need to work with it otherwise.  Remember that
+# your test database is "scratch space" for the test suite and is wiped
+# and recreated between test runs.  Don't rely on the data there!
+config.cache_classes = true
+
+# Log error messages when you accidentally call methods on nil.
+config.whiny_nils = true
+
+# Show full error reports and disable caching
+config.action_controller.consider_all_requests_local = true
+config.action_controller.perform_caching             = false
+
+# Tell ActionMailer not to deliver emails to the real world.
+# The :test delivery method accumulates sent emails in the
+# ActionMailer::Base.deliveries array.
+config.action_mailer.delivery_method = :test

data/starter-app/vendor/plugins/paginating_find/test_app/config/routes.rb

@@ -0,0 +1,22 @@
+ActionController::Routing::Routes.draw do |map|
+  # The priority is based upon order of creation: first created -> highest priority.
+  
+  # Sample of regular route:
+  # map.connect 'products/:id', :controller => 'catalog', :action => 'view'
+  # Keep in mind you can assign values other than :controller and :action
+
+  # Sample of named route:
+  # map.purchase 'products/:id/purchase', :controller => 'catalog', :action => 'purchase'
+  # This route can be invoked with purchase_url(:id => product.id)
+
+  # You can have the root of your site routed by hooking up '' 
+  # -- just remember to delete public/index.html.
+  # map.connect '', :controller => "welcome"
+
+  # Allow downloading Web Service WSDL as a file with an extension
+  # instead of a file named 'wsdl'
+  map.connect ':controller/service.wsdl', :action => 'wsdl'
+
+  # Install the default route as the lowest priority.
+  map.connect ':controller/:action/:id'
+end

data/starter-app/vendor/plugins/paginating_find/test_app/db/schema.rb

@@ -0,0 +1,16 @@
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :authors, :force => true do |t|
+    t.column :name,      :string
+  end
+
+  create_table :edits, :force => true do |t|
+    t.column :author_id,       :integer
+    t.column :article_id,      :integer
+    t.column :text,            :string 
+  end
+
+  create_table :articles, :force => true do |t|
+    t.column :author_id,       :integer
+    t.column :name,            :string
+  end
+end

data/starter-app/vendor/plugins/paginating_find/test_app/script/breakpointer

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../config/boot'
+require 'commands/breakpointer'

data/starter-app/vendor/plugins/paginating_find/test_app/script/console

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../config/boot'
+require 'commands/console'

data/starter-app/vendor/plugins/paginating_find/test_app/test/fixtures/articles.yml

@@ -0,0 +1,19 @@
+testing:
+  id: 1
+  name: Testing Rails Applications
+  author_id: 1
+
+deploying:
+  id: 2
+  name: Deploying Rails Applications
+  author_id: 2
+  
+donkies:
+  id: 3
+  name: What about the donkies?
+  author_id: 2
+  
+whales:
+  id: 4
+  name: Won't somebody think of the whales?
+  author_id: 2   

data/starter-app/vendor/plugins/paginating_find/test_app/test/fixtures/authors.yml

@@ -0,0 +1,7 @@
+alex:
+  id: 1
+  name: Alex Wolfe
+  
+sam:
+  id: 2
+  name: Sam I Am

data/starter-app/vendor/plugins/paginating_find/test_app/test/fixtures/edits.yml

@@ -0,0 +1,11 @@
+new_idea:
+  id: 1
+  text: I have a new idea
+  author_id: 1
+  article_id: 1
+  
+remove_para:
+  id: 2
+  text: Remove paragraph 2
+  author_id: 2
+  article_id: 1

data/starter-app/vendor/plugins/paginating_find/test_app/test/fixtures/models.rb

@@ -0,0 +1,18 @@
+class Author < ActiveRecord::Base
+  has_many :edits
+end
+
+class Edit < ActiveRecord::Base
+  belongs_to :author
+  belongs_to :article
+end
+
+class Article < ActiveRecord::Base
+  has_many :edits
+  has_many :editors, :through => :edits, :source => :author
+  belongs_to :author
+  
+  def self.find_with_scope(options={}, &block)
+    with_scope(:find => options, &block)
+  end
+end

data/starter-app/vendor/plugins/paginating_find/test_app/test/test_helper.rb

@@ -0,0 +1,33 @@
+ENV["RAILS_ENV"] = "test"
+require File.expand_path(File.dirname(__FILE__) + "/../config/environment")
+require 'test_help'
+
+class Test::Unit::TestCase
+  # Transactional fixtures accelerate your tests by wrapping each test method
+  # in a transaction that's rolled back on completion.  This ensures that the
+  # test database remains unchanged so your fixtures don't have to be reloaded
+  # between every test method.  Fewer database queries means faster tests.
+  #
+  # Read Mike Clark's excellent walkthrough at
+  #   http://clarkware.com/cgi/blosxom/2005/10/24#Rails10FastTesting
+  #
+  # Every Active Record database supports transactions except MyISAM tables
+  # in MySQL.  Turn off transactional fixtures in this case; however, if you
+  # don't care one way or the other, switching from MyISAM to InnoDB tables
+  # is recommended.
+  self.use_transactional_fixtures = true
+
+  # Instantiated fixtures are slow, but give you @david where otherwise you
+  # would need people(:david).  If you don't want to migrate your existing
+  # test cases which use the @david style and don't mind the speed hit (each
+  # instantiated fixtures translates to a database query per test method),
+  # then set this back to true.
+  self.use_instantiated_fixtures  = false
+
+  # Add more helper methods to be used by all tests here...
+  
+  def setup
+    RAILS_DEFAULT_LOGGER.debug "\n\e[0;31mRUNNING TEST CASE: #{name}\e[m\n"
+  end
+  
+end

data/starter-app/vendor/plugins/paginating_find/test_app/test/unit/abstract_test.rb

@@ -0,0 +1,7 @@
+
+$:.unshift(File.dirname(__FILE__) + '/../../../lib')
+require 'paginating_find'
+require File.dirname(__FILE__) + '/../test_helper'
+require File.join(File.dirname(__FILE__), '/../fixtures/models')
+load(File.dirname(__FILE__) + "/../../db/schema.rb")
+load(File.dirname(__FILE__) + "/../../../init.rb")

data/starter-app/vendor/plugins/paginating_find/test_app/test/unit/group_test.rb

@@ -0,0 +1,40 @@
+require File.dirname(__FILE__) + '/abstract_test.rb'
+
+class GroupTest < Test::Unit::TestCase
+  def test_should_paginate_with_group
+    one = Article.create(:name => "one", :author_id => 1)
+    two = Article.create(:name => "two", :author_id => 1)
+    three = Article.create(:name => "three", :author_id => 1)
+    four = Article.create(:name => "four", :author_id => 2)
+    results = Article.find(:all, :group => "author_id", :page => {:size => 2})
+    assert_equal 2, results.size
+    assert results.to_a.include?(one)
+    assert !results.to_a.include?(two)
+    assert !results.to_a.include?(three)
+    assert results.to_a.include?(four)
+    assert_equal 1, results.page_count
+    assert_equal 2, results.page_size
+  end
+  
+  def test_should_paginate_with_group_and_order
+    one = Article.create(:name => "one", :author_id => 1)
+    two = Article.create(:name => "two", :author_id => 1)
+    three = Article.create(:name => "three", :author_id => 1)
+    four = Article.create(:name => "four", :author_id => 2)
+    results = Article.find(:all, :group => "author_id", :order => "name DESC", :page => {:size => 2})
+    assert_equal 2, results.size
+    assert_equal 1, results.page_count
+    assert_equal 2, results.page_size
+  end
+  
+  def test_should_work_with_having_tacked_onto_group
+    one = Article.create(:name => "one", :author_id => 1)
+    two = Article.create(:name => "two", :author_id => 1)
+    three = Article.create(:name => "three", :author_id => 1)
+    four = Article.create(:name => "four", :author_id => 2)
+    results = Article.find(:all, :group => "author_id HAVING author_id=1", :order => "name DESC", :page => {:size => 2})
+    assert_equal 1, results.size
+    assert_equal 1, results.page_count
+    assert_equal 2, results.page_size
+  end
+end

data/starter-app/vendor/plugins/paginating_find/test_app/test/unit/paginating_find_test.rb

@@ -0,0 +1,194 @@
+require File.dirname(__FILE__) + '/abstract_test.rb'
+
+class PaginatingFindTest < Test::Unit::TestCase
+  fixtures :authors, :edits, :articles
+  
+  def test_should_not_bonk_on_marshal_dump
+    results = Article.find(:all, :page => {:size => 2})
+    Marshal.dump(results)
+  end
+  
+  def test_should_preserve_enumerator_stats_on_marshal_load
+    results = Article.find(:all, :page => {:size => 2})
+    loaded = Marshal.load(Marshal.dump(results))
+    assert_equal 2, loaded.page_size
+    assert_equal Article.count, loaded.size
+  end
+  
+  def test_should_auto_paginate
+    h = ArticleHelper.new(112)
+    h.find_articles(:all, :page => {:size => 10, :auto => true}) do |results|
+      results.each {} # enumerate all 112 results
+      assert_equal results.page_count, results.stop_page
+      assert_equal results.page_count, results.page
+    end
+  end
+  
+  def test_should_paginate
+    h = ArticleHelper.new(112)
+    h.find_articles(:all, :page => {:size => 10}) do |results|
+      results.each {} # enumerate first 10 results
+      results.next_page! # move to next page
+      results.page = 2
+      results.each {} # enumerate next 10 results
+    end
+  end
+  
+  def test_should_not_paginate
+    results = Article.find(:all)
+    assert !results.respond_to?(:page_count)
+    assert !results.respond_to?(:page_size)
+  end
+  
+  def test_should_paginate_with_conditions
+    h = ArticleHelper.new(20)
+    h.find_articles(:all, :conditions => "name = 1", :order => "name ASC", :page => {:size => 10}) do |results|
+      assert_equal 10, results.page_size
+      assert_equal 1, results.size
+      results.each {} 
+      assert_equal 1, results.page
+      end
+  end
+  
+  def test_should_respect_limit
+    h = ArticleHelper.new(80, 52)
+    h.find_articles(:all, :limit => 52, :page => {:size => 10}) do |results|
+      assert_equal 52, results.size
+      assert_equal 10, results.page_size
+    end
+  end
+  
+  def test_should_not_query_for_count
+    h = ArticleHelper.new(80, 50)
+    h.find_articles(:all, :page => {:size => 10, :count => 50}) do |results|
+      assert_equal 50, results.size
+      assert_equal 10, results.page_size
+    end
+  end
+  
+  def test_should_use_limit_instead_of_count
+    h = ArticleHelper.new(80, 41)
+    h.find_articles(:all, :limit => 41, :page => {:size => 10, :count => 50}) do |results|
+      assert_equal 41, results.size
+      assert_equal 10, results.page_size
+    end
+  end
+  
+  def test_should_use_count_instead_of_limit
+    h = ArticleHelper.new(80, 41)
+    h.find_articles(:all, :limit => 50, :page => {:size => 10, :count => 41}) do |results|
+      assert_equal 41, results.size
+      assert_equal 10, results.page_size
+    end
+  end
+  
+  def test_should_respect_include
+    results = Article.find(:all, 
+                           :conditions => ["authors.id = ?", authors(:alex).id],
+                           :include => [:author],
+                           :page => {:size => 10})
+    assert_equal 1, results.size
+    assert_equal 10, results.page_size
+    assert_equal authors(:alex), results.to_a.first.author
+  end
+  
+  def test_should_correctly_count_through_associations
+    editors = articles(:testing).editors.find(:all,
+                                              :page => {:size => 20,
+                                                        :first => 1,
+                                                        :current => 1 })
+    assert_equal 20, editors.page_size
+    assert_equal articles(:testing).editors.count, editors.size  
+    assert_equal articles(:testing).editors.count, editors.to_a.size                    
+  end
+  
+  def test_should_respect_scope
+    Article.find_with_scope({ :conditions => "name = 1" }) do
+      h = ArticleHelper.new(20)
+      h.find_articles(:all, :page => {:size => 10}) do |results|
+        assert_equal 1, results.size
+        assert_equal 1, results.to_a.size
+        assert_equal 10, results.page_size
+      end
+    end
+  end
+  
+  def test_should_respect_scope_with_include
+    h = ArticleHelper.new(20)
+    Article.find_with_scope({:conditions => "articles.name >= 1 and articles.name <= 3" }) do
+      h.find_articles(:all, :include => [:author, :edits], :page => {:size => 10, :current => 1, :first => 1}, :order => "articles.name ASC") do |results|
+        assert_equal 3, results.size
+        assert_equal 3, results.to_a.size
+        assert_equal 10, results.page_size
+      end
+    end
+  end
+  
+  def test_should_respect_nested_scope
+    h = ArticleHelper.new(20)
+    Article.find_with_scope({ :conditions => "name = 1" }) do
+      Article.find_with_scope({ :conditions => "name = 2" }) do
+        h.find_articles(:all, :page => {:size => 10}) do |results|
+          assert_equal 0, results.size
+          assert_equal 0, results.to_a.size
+          assert_equal 10, results.page_size
+        end
+      end  
+    end
+  end
+  
+  # =)
+  def test_should_respect_out_of_scope_scope
+    results = nil
+    (1..20).each { |n| Article.create(:name => n, :author_id => 1) }
+    Article.find_with_scope({ :conditions => "name >= 1 and name <= 15" }) do
+      results = Article.find(:all, :page => {:size => 10, :auto => true})
+    end
+    assert_equal 10, results.page_size
+    assert_equal 15, results.size
+    assert_equal 15, results.to_a.size
+  end
+  
+  def test_should_respect_out_of_scope_scope_with_include
+    results = nil
+    (1..20).each { |n| Article.create(:name => n, :author_id => 1) }
+    Article.find_with_scope({ :conditions => "articles.name >= 1 and articles.name <= 15 and authors.id = 1", :include => [:author, :edits]}) do
+      results = Article.find(:all, :page => {:size => 10, :auto => true})
+    end
+    assert_equal 10, results.page_size
+    assert_equal 15, results.size
+    assert_equal 15, results.to_a.size
+  end
+  
+end
+
+class ArticleHelper
+  def initialize(how_many, limit=nil)
+    @how_many = how_many
+    @limit=limit
+  end
+  
+  # Create n number of articles, and query them using the specified
+  # arguments. Check that the correct number of pages were returned
+  # and yield the results.
+  #
+  def find_articles(*args)
+    (1..@how_many).each { |n| Article.create(:name => n, :author_id => 1) }
+    results = Article.find(*args)
+    if results.size > results.page_size
+      page_count, num_on_last_page = how_many.divmod(results.page_size)
+      page_count = page_count + 1 if num_on_last_page > 0
+    else 
+      page_count = 1
+    end
+    if (page_count != results.page_count)
+      raise "Expected #{page_count} pages but there were #{results.page_count}"
+    end  
+    yield results if block_given? 
+    results
+  end
+  
+  def how_many
+    @limit ? @limit : @how_many
+  end
+end