spree_core 1.1.6 → 1.2.0.rc1

data/app/models/spree/address.rb

@@ -1,9 +1,9 @@
 module Spree
   class Address < ActiveRecord::Base
-    belongs_to :country, :class_name => "Spree::Country"
-    belongs_to :state, :class_name => "Spree::State"
+    belongs_to :country
+    belongs_to :state
 
-    has_many :shipments, :class_name => "Spree::Shipment"
+    has_many :shipments
 
     validates :firstname, :lastname, :address1, :city, :zipcode, :country, :phone, :presence => true
     validate :state_validate
@@ -36,15 +36,7 @@ module Spree
     end
 
     def state_text
-      state.try(:abbr) || state.try(:name) || state_name 
-    end
-
-    def zone
-      (state && state.zone) || (country && country.zone)
-    end
-
-    def zones
-      @zones ||= Zone.match(self)
+      state.nil? ? state_name : (state.abbr.blank? ? state.name : state.abbr)
     end
 
     def same_as?(other)

data/app/models/spree/adjustment.rb

@@ -31,14 +31,6 @@ module Spree
     validates :label, :presence => true
     validates :amount, :numericality => true
 
-    scope :tax, lambda { where(:originator_type => 'Spree::TaxRate', :adjustable_type => 'Spree::Order') }
-    scope :price, lambda { where(:adjustable_type => 'Spree::LineItem') }
-    scope :shipping, lambda { where(:originator_type => 'Spree::ShippingMethod') }
-    scope :optional, where(:mandatory => false)
-    scope :eligible, where(:eligible => true)
-    scope :charge, where("amount >= 0")
-    scope :credit, where("amount < 0")
-
     after_save :update_adjustable
     after_destroy :update_adjustable
 
@@ -79,5 +71,35 @@ module Spree
         adjustable.update! if adjustable.is_a? Order
       end
 
+      class << self
+        def tax
+          where(:originator_type => 'Spree::TaxRate', :adjustable_type => 'Spree::Order')
+        end
+
+        def price
+          where(:adjustable_type => 'Spree::LineItem')
+        end
+
+        def shipping
+          where(:originator_type => 'Spree::ShippingMethod')
+        end
+
+        def optional
+          where(:mandatory => false)
+        end
+
+        def eligible
+          where(:eligible => true)
+        end
+
+        def charge
+          where('amount >= 0')
+        end
+
+        def credit
+          where('amount < 0')
+        end
+      end
+
   end
 end

data/app/models/spree/app_configuration.rb

@@ -35,7 +35,7 @@ module Spree
     preference :alternative_billing_phone, :boolean, :default => false # Request extra phone for bill addr
     preference :alternative_shipping_phone, :boolean, :default => false # Request extra phone for ship addr
     preference :always_put_site_name_in_title, :boolean, :default => true
-    preference :auto_capture, :boolean, :default => false # automatically capture the creditcard (as opposed to just authorize and capture later)
+    preference :auto_capture, :boolean, :default => false # automatically capture the credit card (as opposed to just authorize and capture later)
     preference :cache_static_content, :boolean, :default => true
     preference :check_for_spree_alerts, :boolean, :default => true
     preference :checkout_zone, :string, :default => nil # replace with the name of a zone if you would like to limit the countries

data/app/models/spree/calculator/price_sack.rb

@@ -1,6 +1,4 @@
 require_dependency 'spree/calculator'
-# For #to_d method on Ruby 1.8
-require 'bigdecimal/util'
 
 module Spree
   class Calculator::PriceSack < Calculator
@@ -19,12 +17,12 @@ module Spree
     # as object we always get line items, as calculable we have Coupon, ShippingMethod
     def compute(object)
       if object.is_a?(Array)
-        base = object.map { |o| o.respond_to?(:amount) ? o.amount : BigDecimal(o.to_s) }.sum
+        base = object.map { |o| o.respond_to?(:amount) ? o.amount : o.to_d }.sum
       else
-        base = object.respond_to?(:amount) ? object.amount : BigDecimal(object.to_s)
+        base = object.respond_to?(:amount) ? object.amount : object.to_d
       end
 
-      if base < self.preferred_minimal_amount
+      if base >= self.preferred_minimal_amount
         self.preferred_normal_amount
       else
         self.preferred_discount_amount

data/app/models/spree/country.rb

@@ -1,9 +1,6 @@
 module Spree
   class Country < ActiveRecord::Base
-    has_many :states, :order => "name ASC", :class_name => "Spree::State"
-
-    has_one :zone_member, :as => :zoneable, :class_name => "Spree::ZoneMember"
-    has_one :zone, :through => :zone_member, :class_name => "Spree::Zone"
+    has_many :states, :order => "name ASC"
 
     validates :name, :iso_name, :presence => true
 

data/app/models/spree/{creditcard.rb → credit_card.rb}

@@ -1,6 +1,6 @@
 module Spree
-  class Creditcard < ActiveRecord::Base
-    has_many :payments, :as => :source, :class_name => "Spree::Payment"
+  class CreditCard < ActiveRecord::Base
+    has_many :payments
 
     before_save :set_last_digits
     after_validation :set_card_type
@@ -14,8 +14,6 @@ module Spree
     attr_accessible :first_name, :last_name, :number, :verification_value, :year,
                     :month, :gateway_customer_profile_id, :gateway_payment_profile_id
 
-    scope :with_payment_profile, where('gateway_customer_profile_id IS NOT NULL')
-
     def set_last_digits
       number.to_s.gsub!(/\s/,'')
       verification_value.to_s.gsub!(/\s/,'')
@@ -65,6 +63,8 @@ module Spree
       cc_type
     end
 
+    scope :with_payment_profile, where('gateway_customer_profile_id IS NOT NULL')
+
     def actions
       %w{capture void credit}
     end

data/app/models/spree/gateway.rb

@@ -6,11 +6,11 @@ module Spree
 
     preference :server, :string, :default => 'test'
     preference :test_mode, :boolean, :default => true
-    
+
     attr_accessible :preferred_server, :preferred_test_mode
 
     def payment_source_class
-      Creditcard
+      CreditCard
     end
 
     # instantiates the selected gateway and configures with the options stored in the database

data/app/models/spree/gateway/bogus.rb

@@ -23,29 +23,29 @@ module Spree
       payment.source.update_attributes(:gateway_customer_profile_id => generate_profile_id(success))
     end
 
-    def authorize(money, creditcard, options = {})
-      profile_id = creditcard.gateway_customer_profile_id
-      if VALID_CCS.include? creditcard.number or (profile_id and profile_id.starts_with? 'BGS-')
+    def authorize(money, credit_card, options = {})
+      profile_id = credit_card.gateway_customer_profile_id
+      if VALID_CCS.include? credit_card.number or (profile_id and profile_id.starts_with? 'BGS-')
         ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345', :avs_result => { :code => 'A' })
       else
         ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', { :message => 'Bogus Gateway: Forced failure' }, :test => true)
       end
     end
 
-    def purchase(money, creditcard, options = {})
-      profile_id = creditcard.gateway_customer_profile_id
-      if VALID_CCS.include? creditcard.number  or (profile_id and profile_id.starts_with? 'BGS-')
+    def purchase(money, credit_card, options = {})
+      profile_id = credit_card.gateway_customer_profile_id
+      if VALID_CCS.include? credit_card.number  or (profile_id and profile_id.starts_with? 'BGS-')
         ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345', :avs_result => { :code => 'A' })
       else
         ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', :message => 'Bogus Gateway: Forced failure', :test => true)
       end
     end
 
-    def credit(money, creditcard, response_code, options = {})
+    def credit(money, credit_card, response_code, options = {})
       ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345')
     end
 
-    def capture(authorization, creditcard, gateway_options)
+    def capture(authorization, credit_card, gateway_options)
       if authorization.response_code == '12345'
         ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '67890')
       else
@@ -54,7 +54,7 @@ module Spree
 
     end
 
-    def void(response_code, creditcard, options = {})
+    def void(response_code, credit_card, options = {})
       ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345')
     end
 
@@ -77,7 +77,7 @@ module Spree
         prefix = success ? 'BGS' : 'FAIL'
         while record
           random = "#{prefix}-#{Array.new(6){rand(6)}.join}"
-          record = Creditcard.where(:gateway_customer_profile_id => random).first
+          record = CreditCard.where(:gateway_customer_profile_id => random).first
         end
         random
       end

data/app/models/spree/gateway/bogus_simple.rb

@@ -6,16 +6,16 @@ module Spree
       false
     end
 
-    def authorize(money, creditcard, options = {})
-      if VALID_CCS.include? creditcard.number
+    def authorize(money, credit_card, options = {})
+      if VALID_CCS.include? credit_card.number
         ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345', :avs_result => { :code => 'A' })
       else
         ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', { :message => 'Bogus Gateway: Forced failure' }, :test => true)
       end
     end
 
-    def purchase(money, creditcard, options = {})
-      if VALID_CCS.include? creditcard.number
+    def purchase(money, credit_card, options = {})
+      if VALID_CCS.include? credit_card.number
         ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345', :avs_result => { :code => 'A' })
       else
         ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', :message => 'Bogus Gateway: Forced failure', :test => true)

data/app/models/spree/image.rb

@@ -9,22 +9,13 @@ module Spree
                       :styles => { :mini => '48x48>', :small => '100x100>', :product => '240x240>', :large => '600x600>' },
                       :default_style => :product,
                       :url => '/spree/products/:id/:style/:basename.:extension',
-                      :path => ':rails_root/public/spree/products/:id/:style/:basename.:extension',
-                      :convert_options => { :all => '-strip' }
+                      :path => ':rails_root/public/spree/products/:id/:style/:basename.:extension'
     # save the w,h of the original image (from which others can be calculated)
     # we need to look at the write-queue for images which have not been saved yet
     after_post_process :find_dimensions
 
-    # Load user defined paperclip settings
-    if Spree::Config[:use_s3]
-      s3_creds = { :access_key_id => Spree::Config[:s3_access_key], :secret_access_key => Spree::Config[:s3_secret], :bucket => Spree::Config[:s3_bucket] }
-      Spree::Image.attachment_definitions[:attachment][:storage] = :s3
-      Spree::Image.attachment_definitions[:attachment][:s3_credentials] = s3_creds
-      Spree::Image.attachment_definitions[:attachment][:s3_headers] = ActiveSupport::JSON.decode(Spree::Config[:s3_headers])
-      Spree::Image.attachment_definitions[:attachment][:bucket] = Spree::Config[:s3_bucket]
-      Spree::Image.attachment_definitions[:attachment][:s3_protocol] = Spree::Config[:s3_protocol] unless Spree::Config[:s3_protocol].blank?
-      Spree::Image.attachment_definitions[:attachment][:s3_host_alias] = Spree::Config[:s3_host_alias] unless Spree::Config[:s3_host_alias].blank?
-    end
+    include Spree::Core::S3Support
+    supports_s3 :attachment
 
     Spree::Image.attachment_definitions[:attachment][:styles] = ActiveSupport::JSON.decode(Spree::Config[:attachment_styles])
     Spree::Image.attachment_definitions[:attachment][:path] = Spree::Config[:attachment_path]

data/app/models/spree/inventory_unit.rb

@@ -7,6 +7,8 @@ module Spree
 
     scope :backorder, where(:state => 'backordered')
 
+    attr_accessible :shipment
+
     # state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
     state_machine :initial => 'on_hand' do
       event :fill_backorder do
@@ -96,8 +98,6 @@ module Spree
 
         shipment = order.shipments.detect { |shipment| !shipment.shipped? }
 
-        attr_accessible :shipment
-
         sold.times { order.inventory_units.create({:variant => variant, :state => 'sold', :shipment => shipment}, :without_protection => true) }
         back_order.times { order.inventory_units.create({:variant => variant, :state => 'backordered', :shipment => shipment}, :without_protection => true) }
       end
@@ -107,10 +107,8 @@ module Spree
       end
 
       def restock_variant
-        if Spree::Config[:track_inventory_levels]
-          variant.on_hand += 1
-          variant.save
-        end
+        variant.on_hand = (variant.on_hand + 1)
+        variant.save
       end
   end
 end

data/app/models/spree/{user.rb → legacy_user.rb}

@@ -1,12 +1,9 @@
-# Default implementation of User.  This class is intended to be modified by extensions (ex. spree_auth)
+# Default implementation of User.  This class is intended to be modified by extensions (ex. spree_auth_devise)
 module Spree
-  class User < ActiveRecord::Base
-    include Core::UserBanners
-
+  class LegacyUser < ActiveRecord::Base
+    self.table_name = 'spree_users'
     attr_accessible :email, :password, :password_confirmation
 
-    has_many :orders
-
     belongs_to :ship_address, :class_name => 'Spree::Address'
     belongs_to :bill_address, :class_name => 'Spree::Address'
 
@@ -21,6 +18,10 @@ module Spree
       create
     end
 
+    def has_spree_role?(role)
+      true
+    end
+
     attr_accessor :password
     attr_accessor :password_confirmation
   end

data/app/models/spree/line_item.rb

@@ -1,11 +1,11 @@
 module Spree
   class LineItem < ActiveRecord::Base
     before_validation :adjust_quantity
-    belongs_to :order, :class_name => "Spree::Order"
-    belongs_to :variant, :class_name => "Spree::Variant"
+    belongs_to :order
+    belongs_to :variant
 
     has_one :product, :through => :variant
-    has_many :adjustments, :as => :adjustable, :class_name => "Spree::Adjustment"
+    has_many :adjustments, :as => :adjustable, :dependent => :destroy
 
     before_validation :copy_price
 
@@ -80,7 +80,6 @@ module Spree
 
       def update_order
         # update the order totals, etc.
-        order.create_tax_charge!
         order.update!
       end
 
@@ -98,7 +97,7 @@ module Spree
       end
 
       def quantity_no_less_than_shipped
-        already_shipped = order.shipments.reduce(0) { |acc,s| acc + s.inventory_units.select { |i| i.variant == variant }.count }
+        already_shipped = order.shipments.reduce(0) { |acc,s| acc + s.inventory_units.count { |i| i.variant == variant } }
         unless quantity >= already_shipped
           errors.add(:quantity, I18n.t('validation.cannot_be_less_than_shipped_units'))
         end

data/app/models/spree/option_type.rb

@@ -1,16 +1,14 @@
 module Spree
   class OptionType < ActiveRecord::Base
-    has_many :option_values, :order => :position, :dependent => :destroy, :class_name => "Spree::OptionValue"
-    has_many :product_option_types, :dependent => :destroy, :class_name => "Spree::ProductOptionType"
-    has_and_belongs_to_many :prototypes, :join_table => 'spree_option_types_prototypes', :class_name => "Spree::Prototype"
+    has_many :option_values, :order => :position, :dependent => :destroy
+    has_many :product_option_types, :dependent => :destroy
+    has_and_belongs_to_many :prototypes, :join_table => 'spree_option_types_prototypes'
 
-    attr_accessible :name, :presentation
+    attr_accessible :name, :presentation, :option_values_attributes
 
     validates :name, :presentation, :presence => true
     default_scope :order => "#{self.table_name}.position"
 
-    attr_accessible :option_values_attributes
-
     accepts_nested_attributes_for :option_values, :reject_if => lambda { |ov| ov[:name].blank? || ov[:presentation].blank? }, :allow_destroy => true
   end
 end

data/app/models/spree/option_value.rb

@@ -1,6 +1,6 @@
 module Spree
   class OptionValue < ActiveRecord::Base
-    belongs_to :option_type, :class_name => "Spree::OptionType"
+    belongs_to :option_type
     acts_as_list :scope => :option_type
     has_and_belongs_to_many :variants, :join_table => 'spree_option_values_variants', :class_name => "Spree::Variant"
 

data/app/models/spree/order.rb

@@ -2,24 +2,38 @@ require 'spree/core/validators/email'
 
 module Spree
   class Order < ActiveRecord::Base
+    include Checkout
+    checkout_flow do
+      go_to_state :address
+      go_to_state :delivery
+      go_to_state :payment, :if => lambda { |order| order.payment_required? }
+      go_to_state :confirm, :if => lambda { |order| order.confirmation_required? }
+      go_to_state :complete
+      remove_transition :from => :delivery, :to => :confirm
+    end
+
+    token_resource
+
     attr_accessible :line_items, :bill_address_attributes, :ship_address_attributes, :payments_attributes,
                     :ship_address, :bill_address, :line_items_attributes, :number,
                     :shipping_method_id, :email, :use_billing, :special_instructions
 
-    belongs_to :user, :class_name => "Spree::User"
+    if Spree.user_class
+      belongs_to :user, :class_name => Spree.user_class.to_s
+    else
+      belongs_to :user
+    end
 
-    belongs_to :bill_address, :foreign_key => 'bill_address_id', :class_name => 'Spree::Address'
-    alias_method :billing_address, :bill_address
-    alias_method :billing_address=, :bill_address=
+    belongs_to :bill_address, :foreign_key => :bill_address_id, :class_name => "Spree::Address"
+    alias_attribute :billing_address, :bill_address
 
-    belongs_to :ship_address, :foreign_key => 'ship_address_id', :class_name => 'Spree::Address'
-    alias_method :shipping_address, :ship_address
-    alias_method :shipping_address=, :ship_address=
+    belongs_to :ship_address, :foreign_key => :ship_address_id, :class_name => "Spree::Address"
+    alias_attribute :shipping_address, :ship_address
 
-    belongs_to :shipping_method, :class_name => "Spree::ShippingMethod"
+    belongs_to :shipping_method
 
     has_many :state_changes, :as => :stateful
-    has_many :line_items, :dependent => :destroy, :order => "created_at ASC"
+    has_many :line_items, :dependent => :destroy
     has_many :inventory_units
     has_many :payments, :dependent => :destroy
     has_many :shipments, :dependent => :destroy
@@ -34,8 +48,10 @@ module Spree
 
     # Needs to happen before save_permalink is called
     before_validation :generate_order_number, :on => :create
+    before_validation :clone_billing_address, :if => :use_billing?
+    attr_accessor :use_billing
 
-    before_create :create_user
+    before_create :link_by_email
     after_create :create_tax_charge!
 
     # TODO: validate the format of the email as well (but we can't rely on authlogic anymore to help with validation)
@@ -48,56 +64,6 @@ module Spree
     class_attribute :update_hooks
     self.update_hooks = Set.new
 
-    # order state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
-    state_machine :initial => 'cart', :use_transactions => false do
-
-      event :next do
-        transition :from => 'cart',     :to => 'address'
-        transition :from => 'address',  :to => 'delivery'
-        transition :from => 'delivery', :to => 'payment', :if => :payment_required?
-        transition :from => 'delivery', :to => 'complete'
-        transition :from => 'confirm',  :to => 'complete'
-
-        # note: some payment methods will not support a confirm step
-        transition :from => 'payment',  :to => 'confirm',
-                                        :if => Proc.new { |order| order.payment_method && order.payment_method.payment_profiles_supported? }
-
-        transition :from => 'payment', :to => 'complete'
-      end
-
-      event :cancel do
-        transition :to => 'canceled', :if => :allow_cancel?
-      end
-      event :return do
-        transition :to => 'returned', :from => 'awaiting_return', :unless=>:awaiting_returns?
-      end
-      event :resume do
-        transition :to => 'resumed', :from => 'canceled', :if => :allow_resume?
-      end
-      event :authorize_return do
-        transition :to => 'awaiting_return'
-      end
-
-      before_transition :to => 'complete' do |order|
-        begin
-          order.process_payments!
-        rescue Core::GatewayError
-          !!Spree::Config[:allow_checkout_on_gateway_error]
-        end
-      end
-
-      before_transition :to => ['delivery'] do |order|
-        order.shipments.each { |s| s.destroy unless s.shipping_method.available_to_order?(order) }
-      end
-
-      after_transition :to => 'complete', :do => :finalize!
-      after_transition :to => 'delivery', :do => :create_tax_charge!
-      after_transition :to => 'payment',  :do => :create_shipment!
-      after_transition :to => 'resumed',  :do => :after_resume
-      after_transition :to => 'canceled', :do => :after_cancel
-
-    end
-
     def self.by_number(number)
       where(:number => number)
     end
@@ -107,7 +73,7 @@ module Spree
     end
 
     def self.by_customer(customer)
-      joins(:user).where("#{Spree::User.table_name}.email" => customer)
+      joins(:user).where("#{Spree.user_class.table_name}.email" => customer)
     end
 
     def self.by_state(state)
@@ -127,17 +93,9 @@ module Spree
       self.update_hooks.add(hook)
     end
 
-    def checkout_steps
-      if payment and payment.payment_method.payment_profiles_supported?
-        %w(address delivery payment confirm complete)
-      else
-        %w(address delivery payment complete)
-      end
-    end
-
     # For compatiblity with Calculator::PriceSack
     def amount
-      line_items.map(&:amount).sum
+      line_items.sum(&:amount)
     end
 
     def to_param
@@ -160,9 +118,14 @@ module Spree
       total.to_f > 0.0
     end
 
+    # If true, causes the confirmation step to happen during the checkout process
+    def confirmation_required?
+      payment_method && payment_method.payment_profiles_supported?
+    end
+
     # Indicates the number of items in the order
     def item_count
-      line_items.map(&:quantity).sum
+      line_items.sum(:quantity)
     end
 
     # Indicates whether there are any backordered InventoryUnits associated with the Order.
@@ -243,22 +206,6 @@ module Spree
       update_hooks.each { |hook| self.send hook }
     end
 
-    def restore_state
-      # pop the resume event so we can see what the event before that was
-      state_changes.pop if state_changes.last.name == 'resume'
-      update_attribute('state', state_changes.last.previous_state)
-
-      if paid?
-        raise 'do something with inventory'
-        #Spree::InventoryUnit.assign_opening_inventory(self) if inventory_units.empty?
-        #shipment.inventory_units = inventory_units
-        #shipment.ready!
-      end
-    end
-
-    before_validation :clone_billing_address, :if => :use_billing?
-    attr_accessor :use_billing
-
     def clone_billing_address
       if bill_address and self.ship_address.nil?
         self.ship_address = bill_address.clone
@@ -279,12 +226,8 @@ module Spree
       true
     end
 
-    def awaiting_returns?
-      return_authorizations.any? { |return_authorization| return_authorization.authorized? }
-    end
-
     def add_variant(variant, quantity = 1)
-      current_item = contains?(variant)
+      current_item = find_line_item_by_variant(variant)
       if current_item
         current_item.quantity += quantity
         current_item.save
@@ -295,23 +238,19 @@ module Spree
         self.line_items << current_item
       end
 
-      # populate line_items attributes for additional_fields entries
-      # that have populate => [:line_item]
-      Variant.additional_fields.select { |f| !f[:populate].nil? && f[:populate].include?(:line_item) }.each do |field|
-        value = ''
-
-        if field[:only].nil? || field[:only].include?(:variant)
-          value = variant.send(field[:name].gsub(' ', '_').downcase)
-        elsif field[:only].include?(:product)
-          value = variant.product.send(field[:name].gsub(' ', '_').downcase)
-        end
-        current_item.update_attribute(field[:name].gsub(' ', '_').downcase, value)
-      end
-
       self.reload
       current_item
     end
 
+    # Associates the specified user with the order.
+    def associate_user!(user)
+      self.user = user
+      self.email = user.email
+      # disable validations since they can cause issues when associating
+      # an incomplete address during the address step
+      save(:validate => false)
+    end
+
     # FIXME refactor this method and implement validation using validates_* utilities
     def generate_order_number
       record = true
@@ -329,14 +268,18 @@ module Spree
     end
 
     def contains?(variant)
-      line_items.detect { |line_item| line_item.variant_id == variant.id }
+      find_line_item_by_variant(variant).present?
     end
 
     def quantity_of(variant)
-      line_item = line_items.find { |line_item| line_item.variant_id == variant.id }
+      line_item = find_line_item_by_variant(variant)
       line_item ? line_item.quantity : 0
     end
 
+    def find_line_item_by_variant(variant)
+      line_items.detect { |line_item| line_item.variant_id == variant.id }
+    end
+
     def ship_total
       adjustments.shipping.map(&:amount).sum
     end
@@ -345,14 +288,16 @@ module Spree
       adjustments.tax.map(&:amount).sum
     end
 
+    # Clear shipment when transitioning to delivery step of checkout if the
+    # current shipping address is not eligible for the existing shipping method
+    def remove_invalid_shipments!
+      shipments.each { |s| s.destroy unless s.shipping_method.available_to_order?(self) }
+    end
+
     # Creates new tax charges if there are any applicable rates. If prices already
     # include taxes then price adjustments are created instead.
     def create_tax_charge!
-      # destroy any previous adjustments (eveything is recalculated from scratch)
-      adjustments.tax.each(&:destroy)
-      price_adjustments.each(&:destroy)
-
-      TaxRate.match(self).each { |rate| rate.adjust(self) }
+      Spree::TaxRate.adjust(self)
     end
 
     # Creates a new shipment (adjustment is created by shipment model)
@@ -366,7 +311,6 @@ module Spree
                                           :address => self.ship_address,
                                           :inventory_units => self.inventory_units}, :without_protection => true)
       end
-
     end
 
     def outstanding_balance
@@ -383,13 +327,9 @@ module Spree
       end
     end
 
-    def creditcards
-      creditcard_ids = payments.from_creditcard.map(&:source_id).uniq
-      Creditcard.scoped(:conditions => { :id => creditcard_ids })
-    end
-
-    def process_payments!
-      ret = payments.each(&:process!)
+    def credit_cards
+      credit_card_ids = payments.from_credit_card.map(&:source_id).uniq
+      CreditCard.scoped(:conditions => { :id => credit_card_ids })
     end
 
     # Finalizes an in progress order after checkout is complete.
@@ -405,7 +345,7 @@ module Spree
         :previous_state => 'cart',
         :next_state     => 'complete',
         :name           => 'order' ,
-        :user_id        => (User.respond_to?(:current) && User.current.try(:id)) || self.user_id
+        :user_id        => self.user_id
       }, :without_protection => true)
     end
 
@@ -455,6 +395,14 @@ module Spree
       end
     end
 
+    def process_payments!
+      begin
+        payments.each(&:process!)
+      rescue Core::GatewayError
+        !!Spree::Config[:allow_checkout_on_gateway_error]
+      end
+    end
+
     def billing_firstname
       bill_address.try(:firstname)
     end
@@ -483,10 +431,20 @@ module Spree
       adjustments.destroy_all
     end
 
+    # destroy any previous adjustments.
+    # Adjustments will be recalculated during order update.
+    def clear_adjustments!
+      adjustments.tax.each(&:destroy)
+      price_adjustments.each(&:destroy)
+    end
+
+    def has_step?(step)
+      checkout_steps.include?(step)
+    end
+
     private
-      def create_user
-        self.email = user.email if self.user and not user.anonymous?
-        self.user ||= User.anonymous!
+      def link_by_email
+        self.email = user.email if self.user
       end
 
       # Updates the +shipment_state+ attribute according to the following logic:
@@ -520,7 +478,7 @@ module Spree
             :previous_state => old_shipment_state,
             :next_state     => self.shipment_state,
             :name           => 'shipment',
-            :user_id        => (User.respond_to?(:current) && User.current && User.current.id) || self.user_id
+            :user_id        => self.user_id
           }, :without_protection => true)
         end
       end
@@ -550,7 +508,7 @@ module Spree
             :previous_state => old_payment_state,
             :next_state     => self.payment_state,
             :name           => 'payment',
-            :user_id        => (User.respond_to?(:current) && User.current && User.current.id) || self.user_id
+            :user_id        => self.user_id
           }, :without_protection => true)
         end
       end
@@ -587,25 +545,25 @@ module Spree
       end
 
       def has_available_shipment
-        return unless :address == state_name.to_sym
+        return unless has_step?("delivery")
+        return unless address?
         return unless ship_address && ship_address.valid?
         errors.add(:base, :no_shipping_methods_available) if available_shipping_methods.empty?
       end
 
       def has_available_payment
-        return unless :delivery == state_name.to_sym
+        return unless delivery?
         errors.add(:base, :no_payment_methods_available) if available_payment_methods.empty?
       end
 
       def after_cancel
-        if shipment_state == 'pending'
-          self.update_attribute(:payment_state, 'credit_owed')
-        end
-
         restock_items!
 
         #TODO: make_shipments_pending
         OrderMailer.cancel_email(self).deliver
+        unless %w(partial shipped).include?(shipment_state)
+          self.payment_state = 'credit_owed'
+        end
       end
 
       def restock_items!