spree 0.0.5

data/starter-app/vendor/plugins/paginating_find/README

@@ -0,0 +1,89 @@
+Visit http://cardboardrocket.com/pages/paginating_find for more documentation.
+
+This plugin makes it easy to page through your model instances by enhancing the default ActiveRecord::Base#find method.  In general, you can expect pagination to work with the standard #find options, including :conditions, :group, :order, :limit, and :include.  To activate paging, just specify the :page option.  You may also provide additional paging options that will control the behavior of the enumerator returned by the #find method.  The following options are supported:
+
+:size    => Number of records in each page of results. Defaults to the total
+            record count or 10, whichever is smaller.
+:current => The current page. Optional, defaults to the first page: 1.
+:first   => The first page. Optional, defaults to the current page.
+:auto    => Automatically load the next page during invocation of #each. Defaults to false.
+:count   => Number of records used to determine #page_count. Specifying this
+            option prevents the plugin from running a count query, which may 
+            be helpful if the table to be queried is very large.
+
+Note: if :page is specified, then the :offset option is not supported and an Exception to that effect will be raised.
+
+Some handy methods you can call on the result returned by #find, when paging is enabled:
+
+#each               => Iterate over the results
+#size               => Number of records on all pages combined (total size)
+#page_size          => Number of records on each page
+#page_count         => Number of pages
+#empty?             => Are there any results?
+#to_a               => Create an array of the records on the current page, or all pages if :auto => true
+#move!(num)         => Move to a specific page number
+#page_exists?(num)  => Does this page number exist?
+#first_page!        => Move to the first page
+#first_page         => Page number of the first page
+#last_page!         => Move to the last page
+#last_page          => Page number of the last page
+#next_page?         => Is there another page available?
+#next_page!         => Move to the next page, if one exists
+#next_page          => Page number of the next page
+#previous_page?     => Does a previous page exist?
+#previous_page!     => Move to the previous page, if one exists
+#previous_page      => Page number of the previous pages
+#first_item         => The index of the first item on the page
+#last_item          => The index of the last item on the page
+#load_page          => Reload the current page
+
+
+
+- Simple Example -------------------------------------------------------
+
+# Get the first page of 'new' Cogs. Each page contains
+# 10 cogs, and no more than 100 cogs will be returned.
+cogs = Cog.find(:all, 
+                :page,
+                :conditions => ["category = 'new'"],
+                :limit => 100)
+
+# Print the name of each cog on the 1st page. Calling #each
+# more than once will cause the 1st page to be printed for 
+# each invocation.
+cogs.each { |cog| puts cog.name }
+
+# The next_page! method must be used to move to the 2nd page.
+cogs.next_page!
+
+# Print the name of each cog on the 2nd page
+cogs.each { |cog| puts cog.name }
+
+
+
+
+
+- Scope Example -------------------------------------------------------
+
+# Get the second page of 'new' Cogs, using the #with_scope method. 
+# Each page contains 15 cogs, and no more than 100 cogs will be returned.
+Cog.with_scope(:find => {:conditions => "category = 'new'", :include => :widget}) do
+  cogs = Cog.find(:all, 
+                  :limit => 100,
+                  :page => { :start => 1,
+                             :current => 2,
+                             :size => 15 })
+end
+
+# Print the name of each cog on the 2nd page.
+cogs.each { |cog| puts cog.name }
+
+# Move to the 3rd page of cogs. The options specified by 
+# with_scope apply, even though a new page is loaded outside 
+# the with_scope block.
+cogs.next_page!
+
+
+... more examples soon.
+
+

data/starter-app/vendor/plugins/paginating_find/init.rb

@@ -0,0 +1,2 @@
+ActiveRecord::Base.send(:include, PaginatingFind)
+ActionView::Base.send(:include, PaginatingFind::Helpers)

data/starter-app/vendor/plugins/paginating_find/lib/paginating_find.rb

@@ -0,0 +1,138 @@
+require 'paging_enumerator'
+require 'paging_helper'
+
+module PaginatingFind
+      
+  def self.included(base)
+    base.extend(ClassMethods)
+    base.class_eval do
+      class << self
+        VALID_FIND_OPTIONS << :page
+        alias_method_chain :find, :pagination
+      end
+    end
+  end
+
+  module ClassMethods
+    DEFAULT_PAGE_SIZE = 10
+    VALID_COUNT_OPTIONS = [:select, :conditions, :joins, :distinct, :include, :having, :group]
+    
+    # Enhancements to Base find method to support record paging. The :page option
+    # is used to specify additional paging options.  The supported :page options are:
+    #
+    # * <tt>:size</tt>: Number of records in each page of results. Defaults to 1/10
+    #                   the total size if total size > 10, otherwise defaults to 1.
+    # * <tt>:current</tt>: The current page. Optional, defaults to the first page: 1.
+    # * <tt>:first</tt>: The first page. Optional, defaults to the first page: 1.
+    # * <tt>:auto</tt>: Automatically load the next page during invocation of #each. Defaults to false.
+    # * <tt>:count</tt>: The total record count used to determine the number of pages
+    #                    to be loaded. Optional. If not specified, the plugin will
+    #                    use the AR::Calculations#count method.
+    #
+    #
+    # If :page is specified, then the enumerable returned will automatically page the 
+    # result set for this find operation according to the additional options. Note that
+    # if you specify :page, you are getting back and Enumerable, not an Array.
+    #
+    # You can, however, invoke the #to_a method on the Enumerable. If you’ve got 
+    # :auto paging turned off (default), then you’ll get back just the items on 
+    # the current page. Otherwise, you’ll get all items on all pages.
+    #
+    # Heres a sample of how the paging options might be specified:
+    #
+    # cogs = Cog.find(:all,
+    #                 :limit => 3000,
+    #                 :page => {:size => 10,
+    #                           :first => 1,
+    #                           :current => 1, 
+    #                           :auto => true})
+    #
+    def find_with_pagination(*args)
+      options = if args.respond_to?(:extract_options!)
+        args.extract_options!
+      else
+        extract_options_from_args!(args)
+      end
+      page_options = options.delete(:page) || (args.delete(:page) ? {} : nil)
+      if page_options
+        # The :page option was specified, so page the query results
+        raise ArgumentError, ":offset option is not supported when paging results" if options[:offset]
+        current = page_options[:current] && page_options[:current].to_i > 0 ? page_options[:current] : 1
+        first = page_options[:first] || 1
+        auto = page_options[:auto] || false
+        
+        # Specify :count to prevent a count query.
+        unless (count = page_options.delete(:count))
+          original_table_name = self.table_name
+          count = count(collect_count_options(options))
+          count = count.length if options[:group]
+        end
+        
+        # Total size is either count or limit, whichever is less
+        limit = options.delete(:limit)
+        total_size = limit ? [limit, count].min : count
+
+        # If :size isn't specified, then use the lesser of the total_size
+        # and the default page size
+        page_size = page_options[:size] || [total_size, DEFAULT_PAGE_SIZE].min
+        
+        # Cache the :with_scope options so that they can be reused
+        # during enumerator callback invocation
+        cached_scoped_methods = self.scoped_methods.last
+        
+        PagingEnumerator.new(page_size, total_size, auto, current, first) do |page|
+          args.pop if args.last.is_a?(Hash)
+          
+          # Set appropriate :offset and :limit options for this page
+          options[:offset] = (page - 1) * page_size 
+          options[:limit] = (page_size) < total_size ? page_size : total_size
+          
+          if cached_scoped_methods
+            # :with_scope options were specified, so 
+            # the with_scope method must be invoked
+            self.with_scope(cached_scoped_methods) do
+              find_without_pagination(*(args << options))
+            end
+          else
+            find_without_pagination(*(args << options))
+          end
+        end
+      else
+        # The :page option was not specified, so invoke the
+        # usual AR::Base#find method
+        find_without_pagination(*(args << options))
+      end
+    end
+    
+    def collect_count_options(options)
+      rtn = {}.merge(options)
+      
+      table = options[:from] || table_name 
+      
+      # If original :select includes the distinct keyword, then
+      # also include it in the count query
+      if rtn[:select].to_s.index(/\s*DISTINCT\s+/i) != nil
+        rtn[:select] = "DISTINCT #{table}.#{primary_key}"
+      else
+        rtn[:select] = "#{table}.#{primary_key}"
+      end
+      
+      # AR::Base#find does not support :having, but some folks tack it on to the :group option,
+      # and it is supported by calculations, so we'll support it here.
+      scope = scope(:find)
+      group = options[:group] || (scope ? scope[:group] : nil)
+      if group
+        having = group.split(/\s+HAVING\s+/i)
+        if having.size == 2 # 'HAVING' was tacked on to the :group option.
+          rtn[:group] = having[0]
+          rtn[:having] = having[1]
+        end
+      end
+      
+      # Eliminate count options like :order, :limit, :offset.
+      rtn.delete_if { |k, v| !VALID_COUNT_OPTIONS.include?(k.to_sym) }
+      rtn
+    end
+    
+  end
+end

data/starter-app/vendor/plugins/paginating_find/lib/paging_enumerator.rb

@@ -0,0 +1,158 @@
+# An enumerable that iterates through "pages" of objects.
+# A page is loaded by the block callback provided to the initializer.
+#
+#   pe = PagingEnumerable.new(25, 593) do |current_page|
+#     # return all results for the current_page!
+#   end
+#   pe.each { |result| puts result }
+#
+# Specify auto = true if you want the enumerator
+# to iterate over all items rather than just those on the
+# current page. If this option is enabled you may skip to the 
+# next page by invoking the next_page! method, or you may skip 
+# to any page using the move!(page) method.
+# 
+# The callback may return an Enumerable containing the results
+# for the current page, or an object if only one result is 
+# available for the current page.
+#
+# Author::    Alex Wolfe
+# Copyright:: Copyright (c) 2006 Alex Wolfe
+# License::   Distributes under the same terms as Ruby
+# More Info:: http://cardboardrocket.com
+#
+class PagingEnumerator
+  include Enumerable
+
+  attr_accessor :results, :page, :first_page, :last_page, :stop_page, :page_size, :page_count, :size, :auto
+
+  def initialize(page_size, size, auto = false, page = 1, first_page=page, &callback)
+    self.page = page.to_i
+    self.page_size = page_size.to_i
+    self.size = size.to_i
+    self.auto = auto
+    self.first_page = first_page.to_i
+    self.last_page = page_count.to_i
+    self.stop_page = auto ? last_page : self.page
+    @callback = callback
+  end
+  
+  def each
+    early_termination = false
+    while page <= stop_page && !early_termination
+      load_page
+      if results.respond_to?(:each)
+        results.each { |r| yield r }
+      else
+        yield results
+      end
+      self.page = self.page + 1
+      if (results.respond_to?(:size) && results.size < page_size)
+        early_termination = true
+      end
+    end
+    # force usage of next_page method
+    self.page = self.page - 1
+    self
+  end
+  
+  def move!(page)
+    raise ArgumentError, "manually moving pages is only supported when auto paging is disabled" if auto
+    if page < self.first_page
+      self.page = first_page
+    elsif page > self.last_page
+      self.page = last_page
+    else
+      self.page = page
+    end
+    self.stop_page = page
+  end
+  
+  def page_exists?(page)
+    page >= self.first_page && page <= self.last_page
+  end
+  
+  def first_page!
+    move!(first_page)
+  end
+  
+  def last_page!
+    move!(last_page)
+  end
+  
+  # Move to the next page if auto paging is disabled.
+  def next_page!
+    move!(next_page) if next_page?
+  end
+  
+  def next_page?
+    next_page ? true : false
+  end
+  
+  def next_page
+    page >= page_count ? nil : page + 1
+  end
+  
+  # Move to the previous page if auto paging is disabled.
+  def previous_page!
+    move!(previous_page) if previous_page?
+  end
+  
+  def previous_page?
+    previous_page ? true : false
+  end
+  
+  def previous_page
+    page == first_page ? nil : page - 1
+  end
+  
+  def first_item
+    ((self.page-1) * self.page_size) + 1
+  end
+  
+  def last_item
+    [self.page * self.page_size, self.size].min
+  end
+
+  # How many pages are available?
+  def page_count
+    @page_count ||= (empty? or page_size == 0) ? 1 : (q, r = size.divmod(page_size); r == 0 ? q : q + 1)
+  end
+  
+  def empty?
+    size == 0
+  end
+  
+  # Get the results as an array. If the enumerator is not using :auto, this array
+  # will contain just the current page. Otherwise, this method will iterate all pages
+  # and return them as an array.
+  def to_a
+    array = []
+    each { |e| array << e }
+    array
+  end
+  
+  def to_xml(options = {})
+    to_a.to_xml(options)
+  end  
+
+  # Load the next page using the callback
+  def load_page
+    raise "Cannot load page because callback is not available. Has this enumerator been serialized?" unless @callback
+    self.results = @callback.call(page)
+  end
+  
+  def _dump(depth)
+    load_page
+   Marshal.dump([results, page_size, size, false, page, first_page])
+  end
+  
+  def PagingEnumerator._load(str)
+    params = Marshal.load(str)
+    results = params.shift
+    e = PagingEnumerator.new(*params)
+    e.results = results
+    e
+  end
+    
+end

data/starter-app/vendor/plugins/paginating_find/lib/paging_helper.rb

@@ -0,0 +1,47 @@
+module PaginatingFind
+  module Helpers
+    DEFAULT_OPTIONS = { :name => :page, :window_size => 2, 
+      :always_show_anchors => true, :link_to_current_page => false, 
+      :params => {} }
+
+    def paginating_links(paginator, options = {}, html_options = {})
+      name = options[:name] || DEFAULT_OPTIONS[:name]
+      params = (options[:params] || DEFAULT_OPTIONS[:params]).clone
+
+      paginating_links_each(paginator, options) do |n|
+        params[name] = n
+        link_to(n, params, html_options)
+      end
+    end
+
+    def paginating_links_each(paginator, options = {})
+      options = DEFAULT_OPTIONS.merge(options)
+
+      window = ((paginator.page - options[:window_size] + 1)..(paginator.page + options[:window_size] - 1)).select {|w| w >= paginator.first_page && w <= paginator.last_page }
+
+      html = ''
+
+      if options[:always_show_anchors] && !window.include?(paginator.first_page)
+        html << yield(paginator.first_page)
+        html << ' ... ' unless window.first - 1 == paginator.first_page
+        html << ' '
+      end
+
+      window.each do |p|
+        if paginator.page == p && !options[:link_to_current_page]
+          html << p.to_s
+        else
+          html << yield(p)
+        end
+        html << ' '
+      end
+
+      if options[:always_show_anchors] && !window.include?(paginator.last_page)
+        html << ' ... ' unless window.last + 1 == paginator.last_page
+        html << yield(paginator.last_page)
+      end
+
+      html
+    end
+  end
+end

data/starter-app/vendor/plugins/paginating_find/test_app/Rakefile

@@ -0,0 +1,10 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require(File.join(File.dirname(__FILE__), 'config', 'boot'))
+
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+require 'tasks/rails'