spree 0.6.0 → 0.7.0

data/app/controllers/creditcards_controller.rb

@@ -1,73 +0,0 @@
-class CreditcardsController < Spree::BaseController
-  before_filter :load_data
-  before_filter :validate_payment, :only => :create   
-  before_filter :state_check, :except => [:country_changed, :cvv]  
-  ssl_required :new, :create
-  layout 'application'
-  resource_controller
-  
-  belongs_to :order
-  actions :new, :create
-
-  # override the r_c create since we need special logic to deal with the presenter in the create case
-  def create
-    creditcard = @payment_presenter.creditcard
-    creditcard.address = @payment_presenter.address
-    creditcard.order = @order
-    
-    begin
-      creditcard.authorize(@order.total)
-    rescue Spree::GatewayError => ge
-      flash.now[:error] = "Authorization Error: #{ge.message}"
-      render :action => "new" and return 
-    end
-    creditcard.save
-    @order.next!
-    redirect_to checkout_order_url(@order)
-  end
-
-  def cvv
-    render :layout => false
-  end
-  
-  def country_changed
-    render :partial => "shared/states", :locals => {:presenter_type => "creditcard"}
-  end
-  
-  private
-  def load_data 
-    load_object
-    @selected_country_id = params[:payment_presenter][:address_country_id].to_i if params.has_key?('payment_presenter')
-    @selected_country_id ||= @order.ship_address.country_id unless @order.nil? || @order.ship_address.nil?  
-    @selected_country_id ||= Spree::Config[:default_country_id]
- 
-    @states = State.find_all_by_country_id(@selected_country_id, :order => 'name')  
-    @countries = Country.find(:all)
-  end
-  
-  def build_object
-    address = parent_object.ship_address ? parent_object.ship_address : Address.new(:country_id => @selected_country_id)
-    @payment_presenter ||= PaymentPresenter.new(:address => address)    
-  end
-  
-  def validate_payment
-    # load the object so that its available to the form in the event of a validation error
-    load_object
-    load_payment_presenter
-    render :action => "new" unless @payment_presenter.valid?
-  end
-  
-  def load_payment_presenter
-    payment_presenter = PaymentPresenter.new(params[:payment_presenter]) 
-    payment_presenter.creditcard.first_name = payment_presenter.address.firstname
-    payment_presenter.creditcard.last_name = payment_presenter.address.lastname
-    @payment_presenter = payment_presenter
-  end
-  
-  def state_check
-    if @order.checkout_complete
-      # if order has already completed user shouldn't be able to enter new cc information
-      redirect_to checkout_order_url(@order) and return 
-    end
-  end  
-end

data/app/models/order_filter.rb

@@ -1,28 +0,0 @@
-# Tableless model based on a forum post by Rick Olson
-class OrderFilter < ActiveRecord::Base
-  #Search criteria does not need to be stored in the database so these two methods will spoof the column stuff
-  def self.columns() @columns ||= []; end
-  def self.column(name, sql_type = nil, default = nil, null = true)
-    columns << ActiveRecord::ConnectionAdapters::Column.new(name.to_s, default, sql_type.to_s, null)
-  end
-  
-  column :start, :string
-  column :stop, :string
-  column :number, :string
-  column :state, :string
-  column :customer, :string
-  column :checkout, :string
-  column :firstname, :string
-  column :lastname, :string
-  
-  def validate
-    date_pattern = /^(0[1-9]|1[012])[\/][0-9]{2}[\/](19|20)[0-9]{2}$/
-    errors.add(:start, "Must specify a start date") and return if start.blank? and not stop.blank?
-    errors.add(:start, "Date must be formatted MM/DD/YYYY") unless start.blank? or date_pattern.match start.to_s
-    errors.add(:stop, "Date must be formatted MM/DD/YYYY") unless stop.blank? or date_pattern.match stop.to_s
-    unless stop.blank? 
-      errors.add(:stop, "Stop date must be after start date") if DateTime.parse(stop) < DateTime.parse(start)  
-    end
-  end
-  
-end

data/app/models/user_filter.rb

@@ -1,6 +0,0 @@
-class UserFilter < ActiveRecord::Base
-  has_no_table
-
-  column :email, :string
-
-end

data/app/views/creditcards/_form_credit_card.html.erb

@@ -1,30 +0,0 @@
-<h4><%= t("payment_information") %></h4>
-<table id="creditcard">
-  <tr>
-    <td colspan=2>
-      <%= image_tag "creditcard.gif", :id => 'creditcard-image' %>
-    </td>
-  </tr>
-  <tr>
-    <!-- use this sample (visa) cc# for testing 4111111111111111 -->
-    <td width="120"><%= t("card_number") %></td>
-    <td><%= f.text_field :creditcard_number, :size=> 19 -%></td>
-  </tr>
-  <tr>
-    <td><%= t("expiration_month") %></td>
-    <td><%= f.text_field :creditcard_month, :size => 4 -%></td>
-  </tr>
-  <tr>
-    <td><%= t("expiration_year") %></td>
-    <td><%= f.text_field :creditcard_year, :size => 4 -%></td>
-  </tr>
-  <tr>
-    <td><%= t("card_code") %></td>
-    <td>
-      <%= f.text_field :creditcard_verification_value, {:style => "width:40px"} -%>
-      <a href="" onclick="window.open('/creditcards/cvv','mywin','left=20,top=20,width=500,height=500,toolbar=0,resizable=0,scrollbars=1');return false">
-	(<%= t("whats_this") %>)
-      </a>
-    </td>
-  </tr>
-</table>

data/app/views/creditcards/new.html.erb

@@ -1,25 +0,0 @@
-<div id="creditcard">
-  <%=error_messages_for :payment_presenter %>
-  <h1><%= t("payment")%></h1>
-  <% form_for(:payment_presenter, :url => order_creditcards_url(@order)) do |f| %>
-    <table cellpadding="5" width="100%">
-      <tr>
-        <td valign="top" wdith="50%">
-          <%= render :partial => 'form_credit_card', :locals => {:f => f} %>
-        </td>
-        <td>
-					<h4><%= t("billing_address")%></h4>
-					<%= render :partial => 'shared/form_address', :locals => {:f => f, :presenter_type => "payment"} %>
-        </td>
-      </tr>
-    </table>
-  	<div align="right" style="font-size:120%;">
-  		<br />
-  		<%= t("order_total_message") %> <strong><%= number_to_currency @order.total%></strong>
-  	</div>
-    <div align="right">
-  		<br/>
-      <%= submit_tag t('continue') %>
-    </div>
-  <% end %>
-</div>

data/app/views/shared/_paginate.html.erb

@@ -1,34 +0,0 @@
-<!-- Code by Ilya Grigorik - http://www.igvita.com/blog/2006/09/10/faster-pagination-in-rails/ -->
-<% if collection.page_count != collection.first_page -%>
-<div class="pagination">
-  <ul>
-    <% if collection.previous_page? -%>
-    <li class="nextpage">
-      <%= link_to "&#171; #{t('previous')}", { :p => collection.previous_page }.merge(options) %>
-    </li>
-    <% else -%>
-    <li class="disablepage">&#171; <%= t('previous') %></li>
-    <% end -%>
-    
-    <% last_page = 0 -%>
-    <% windowed_pagination_links(collection, :window_size => 2, :link_to_current_page => true, :always_show_anchors => true) do |n| -%>
-    <% if collection.page == n -%>
-    <li class="currentpage"><%= n %></li>
-    <% else -%>
-    <li><%= "..." if last_page+1 < n %>
-	    <%= link_to n, {:id => params[:id], :p => n}.merge(options) %>
-    </li>
-    <% end -%>
-    <% last_page = n -%>
-    <% end -%>
-    
-    <% if collection.next_page? -%>
-    <li class="nextpage">
-      <%=  link_to "#{t('next')} &#187;", { :p => collection.next_page }.merge(options) %>
-    </li>
-    <% else -%>
-    <li class="disablepage">&#171; <%= t('next') %></li>
-    <% end -%>
-  </ul>
-</div>
-<% end -%>

data/lib/plugins/paginating_find/CHANGELOG

@@ -1,120 +0,0 @@
-2008-02-08
-* Count query now uses the :from find option, if specified. Thanks to Rich Wertz.
-
-2007-11-13
-* Removed extraneous statement from collect_count_options. Thanks to Wolfgang Postler.
-
-2007-9-14
-* Count query now respects the distinct keyword if it is included in the :select option.  Thanks to Luke Pearce.
-
-2007-8-25
-* PagingEnumerator#each now returns self.  Thanks to Takeru Sasaki.
-* Addeed #to_xml to the PagingEnumerator.
-
-2007-8-24
-* No longer overwrite the AR #validate_find_options method. Instead just append :page to VALID_FIND_OPTIONS. Thanks for the suggestion Pratik.
-
-2007-7-24
-* Fixed a bug in handling the HAVING having clause. Thanks to Daniel Aborg for the patch!
-* Added support for Array#extract_options! added to Rails edge (9087).  Thanks to Alex Payne!
-* Tests no longer use with_scope since it became protected in Rails edge.
-
-2007-5-7
-* Now uses alias_method_chain. Thanks to Jeremy Larkin for the patch.
-
-2007-4-27
-* PagingEnumerator now supports Marshal.dump and Marshal.load. When marshaled, the enumerator loses its callback, so :auto => true is not supported in this scenario.
-
-2007-02-05
-* :current < 1 is now gracefully handled.  Thanks again to Benjamin Curtis and 21st Century Music.
-
-2007-01-24
-* Added paging_helper that provides paginating_links and paginating_links_each to ActionView::Base. Special thanks to Benjamin Curtis and 21st Century Music (http://21cmusic.com/)!
-
-2007-01-07
-* :first now defaults to 1 rather than the value of :page. Thanks to Jack Baty for bringing this to my attention.
-
-2006-12-28
-* primary_key used to build count select statement rather than "id" column. Thanks to Rich Cox.
-
-2006-12-21
-* Applied another fix to counting with :group option. Special thanks to Ben Weiner.
-* Placed tests for grouping in a separate class.
-
-2006-12-12
-* Removed rails from vendor directory.
-
-2006-11-27
-* For purposes of counting, the HAVING statement is now extracted from the :group option as a convenience for users that are hacking around the lack of a AR#find :having option. Thanks to Gavin Joyce for pointing out this usage of :group. More info here: http://www.mail-archive.com/rails-core@lists.rubyonrails.org/msg01876.html.
-* For purposes of counting, the :select option is now ignored in favor of table_name.id. Thanks to Aron Atkins for reporting a bug that led to this fix.
-
-2006-10-17
-* Count query no longer uses :limit. This option doesn't have the same effect on count as it does on find. The :limit is applied to the count after the query is performed, if necessary.
-* Count query no longer uses :group. Grouping during a count doesn't get any different count than not grouping.
-* Count query no longer uses :order for the same reasons that :group is no longer used.
-
-2006-09-26
-* Change log is now in reverse chronological order
-* Count query now respects :group and :order. Previous changes removing this functionality are no longer applicable.
-
-2006-09-19
-* Added :count option. Using this will cause the plugin to skip the automatic database count query (which can sometimes be slow).
-* The :limit option no longer affects whether the count query will run.
-* Fixed a bug reported by Lisa, where the count query was choking on grouped results. The count query now ignores :group.
-
-2006-09-14
-* Scoping now works correctly, even when enumeration is done outside the #with_scope code block.
-* Added the #empty? method.
-* Added #first_item and #last_item, which return the index of the first and last items on the current page. Thanks, Ilya!
-
-2006-09-10
-* Now works correctly :with_scope, nested :with_scope, and :include.
-* Now correctly counts when querying on through associations.
-* Rewrote paginating_find_test so that it uses real AR::Base models, rather than mocks.
-* Trying out a bare-bones instance of rails in order to run tests without having to install the plugin.
-
-2006-09-10
-* next_page? and previous_page? now return booleans rather than the page number. Thanks, Hammed.
-* next_page and previous_page have been added.
-* The total count now correctly respects conditions, includes, etc.  Thanks, Ilya
-
-2006-09-09
-* ArgumentError is now correctly thrown if options[:offset] is used. Thanks, jonni!
-
-2006-09-08
-* :conditions are now correctly respected when paging is enabled
-* :size now defaults to total number of records if less than ten.
-
-2006-09-06
-* Added #last_page! method. Only works when :auto => true.
-* Added #first_page! method. Only works when :auto => true.
-* Added the #move!(page) method. Only works when :auto => true.
-* Added the #previous_page!(page) method. Only works when :auto => true.
-* Added the #page_exists?(page) method.
-* The #load_page method is no longer protected.
-* Fixed bug in #to_a that was causing :limit to be exceeded.
-* An ArgumentError is now raised if both :page and :offset options are specified
-* The first page and current page can be specified separately, using the :first and :current options respectively.
-* Reversed semantics of automatic pagination. By default, the enumerator will stop after all records on current page. To enumerate all records, pass option :auto => true.
-* :manual_paging is no longer supported.  Use the :auto option instead. :auto defaults to false.
-* All paging options are now specified in a hash, keyed by :page.  This is mostly an aesthetics issue:
-	# The old way:
-    cogs = Cog.find(:all,
-                    :limit => 3000,
-                    :page_size => 10,
-                    :page => 1,
-                    :manual_paging => true)
-
-	# The new way:
-    cogs = Cog.find(:all,
-                    :limit => 3000,
-                    :page => {:size => 10,
-                              :current => 1})
-
-* The following :page options are supported in this revision:
-    :size    => Number of records in each page of results. Defaults to 1/10
-                the total size if total size > 10, otherwise defaults to
-                the total size.
-    :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.

data/lib/plugins/paginating_find/README

@@ -1,89 +0,0 @@
-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/lib/plugins/paginating_find/init.rb

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

data/lib/plugins/paginating_find/lib/paginating_find.rb

@@ -1,138 +0,0 @@
-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