spree_core 0.40.4 → 0.50.0

data/app/models/gateway/eway.rb

@@ -1,11 +1,11 @@
 class Gateway::Eway < Gateway
   preference :login, :string
-  
+
   # Note: EWay supports purchase method only (no authorize method).
   # Ensure Spree::Config[:auto_capture] is set to true
-  
+
   def provider_class
     ActiveMerchant::Billing::EwayGateway
   end
-  
+
 end

data/app/models/image.rb

@@ -1,7 +1,7 @@
 class Image < Asset
   validate :no_attachement_errors
-  has_attached_file :attachment, 
-                    :styles => { :mini => '48x48>', :small => '100x100>', :product => '240x240>', :large => '600x600>' }, 
+  has_attached_file :attachment,
+                    :styles => { :mini => '48x48>', :small => '100x100>', :product => '240x240>', :large => '600x600>' },
                     :default_style => :product,
                     :url => "/assets/products/:id/:style/:basename.:extension",
                     :path => ":rails_root/public/assets/products/:id/:style/:basename.:extension"
@@ -9,8 +9,9 @@ class Image < Asset
   # 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
+
   def find_dimensions
-    temporary = attachment.queued_for_write[:original] 
+    temporary = attachment.queued_for_write[:original]
     filename = temporary.path unless temporary.nil?
     filename = attachment.path if filename.blank?
     geometry = Paperclip::Geometry.from_file(filename)
@@ -22,7 +23,7 @@ class Image < Asset
   def no_attachement_errors
     unless attachment.errors.empty?
       # uncomment this to get rid of the less-than-useful interrim messages
-      # errors.clear 
+      # errors.clear
       errors.add :attachment, "Paperclip returned errors for file '#{attachment_file_name}' - check ImageMagick installation or image source file."
       false
     end

data/app/models/option_type.rb

@@ -3,6 +3,7 @@ class OptionType < ActiveRecord::Base
   has_many :product_option_types, :dependent => :destroy
   has_and_belongs_to_many :prototypes
   validates :name, :presentation, :presence => true
+  default_scope :order => "option_types.position"
 
   accepts_nested_attributes_for :option_values, :reject_if => lambda { |ov| ov[:name].blank? || ov[:presentation].blank? }, :allow_destroy => true
 end

data/app/models/order.rb

@@ -1,6 +1,7 @@
 class Order < ActiveRecord::Base
 
-  attr_accessible :line_items, :bill_address_attributes, :ship_address_attributes, :payments_attributes, :ship_address, :line_items_attributes,
+  attr_accessible :line_items, :bill_address_attributes, :ship_address_attributes, :payments_attributes,
+                  :ship_address, :line_items_attributes,
                   :shipping_method_id, :email, :use_billing, :special_instructions
 
   belongs_to :user
@@ -26,6 +27,7 @@ class Order < ActiveRecord::Base
   before_create :generate_order_number
 
   validates_presence_of :email, :if => :require_email
+  validate :has_available_shipment
 
   #delegate :ip_address, :to => :checkout
   def ip_address
@@ -33,8 +35,8 @@ class Order < ActiveRecord::Base
   end
 
   scope :by_number, lambda {|number| where("orders.number = ?", number)}
-  scope :between, lambda {|*dates| where("orders.created_at between :start and :stop").where(:start, dates.first.to_date).where(:stop, dates.last.to_date)}
-  scope :by_customer, lambda {|customer| where("uses.email =?", customer).includes(:user)}
+  scope :between, lambda {|*dates| where("orders.created_at between ? and ?", dates.first.to_date, dates.last.to_date)}
+  scope :by_customer, lambda {|customer| joins(:user).where("users.email =?", customer)}
   scope :by_state, lambda {|state| where("state = ?", state)}
   scope :complete, where("orders.completed_at IS NOT NULL")
   scope :incomplete, where("orders.completed_at IS NULL")
@@ -43,7 +45,7 @@ class Order < ActiveRecord::Base
 
   attr_accessor :out_of_stock_items
 
-  class_inheritable_accessor :update_hooks
+  class_attribute :update_hooks
   self.update_hooks = Set.new
 
   # Use this method in other gems that wish to register their own custom logic that should be called after Order#updat
@@ -75,12 +77,15 @@ class Order < ActiveRecord::Base
   state_machine :initial => 'cart', :use_transactions => false do
 
     event :next do
-      transition :from => 'cart', :to => 'address'
-      transition :from => 'address', :to => 'delivery'
+      transition :from => 'cart',     :to => 'address'
+      transition :from => 'address',  :to => 'delivery'
       transition :from => 'delivery', :to => 'payment'
-      transition :from => 'confirm', :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 { Gateway.current and Gateway.current.payment_profiles_supported? }
+      transition :from => 'payment',  :to => 'confirm',
+                                      :if => Proc.new { Gateway.current && Gateway.current.payment_profiles_supported? }
+
       transition :from => 'payment', :to => 'complete'
     end
 
@@ -221,13 +226,15 @@ class Order < ActiveRecord::Base
     current_item
   end
 
+  # FIXME refactor this method and implement validation using validates_* utilities
   def generate_order_number
     record = true
     while record
       random = "R#{Array.new(9){rand(9)}.join}"
-      record = Order.find(:first, :conditions => ["number = ?", random])
+      record = self.class.find(:first, :conditions => ["number = ?", random])
     end
-    self.number = random
+    self.number = random if self.number.blank?
+    self.number
   end
 
   # convenience method since many stores will not allow user to create multiple shipments
@@ -250,12 +257,8 @@ class Order < ActiveRecord::Base
   # Creates a new tax charge if applicable.  Uses the highest possible matching rate and destroys any previous
   # tax charges if they were created by rates that no longer apply.
   def create_tax_charge!
-    return unless rate = TaxRate.match(bill_address) or adjustments.tax.present?
-    if old_charge = adjustments.tax.first
-      old_charge.destroy unless old_charge.originator == rate
-      return
-    end
-    rate.create_adjustment(I18n.t(:tax), self, self, true)
+    adjustments.tax.each {|e| e.destroy }
+    TaxRate.match(ship_address).each {|r| r.create_adjustment(I18n.t(:tax), self, self, true) }
   end
 
   # Creates a new shipment (adjustment is created by shipment model)
@@ -264,7 +267,9 @@ class Order < ActiveRecord::Base
     if shipment.present?
       shipment.update_attributes(:shipping_method => shipping_method)
     else
-      self.shipments << Shipment.create(:order => self, :shipping_method => shipping_method, :address => self.ship_address)
+      self.shipments << Shipment.create(:order => self,
+                                        :shipping_method => shipping_method,
+                                        :address => self.ship_address)
     end
 
   end
@@ -283,8 +288,9 @@ class Order < ActiveRecord::Base
   end
 
   def name
-    address = bill_address || ship_address
-    "#{address.firstname} #{address.lastname}" if address
+    if (address = bill_address || ship_address)
+      "#{address.firstname} #{address.lastname}"
+    end
   end
 
   def creditcards
@@ -304,6 +310,13 @@ class Order < ActiveRecord::Base
     # lock any optional adjustments (coupon promotions, etc.)
     adjustments.optional.each { |adjustment| adjustment.update_attribute("locked", true) }
     OrderMailer.confirm_email(self).deliver
+
+    self.state_events.create({
+      :previous_state => "cart",
+      :next_state     => "complete",
+      :name           => "order" ,
+      :user_id        => (User.respond_to?(:current) && User.current.try(:id)) || self.user_id
+    })
   end
 
 
@@ -316,12 +329,13 @@ class Order < ActiveRecord::Base
 
   def rate_hash
     @rate_hash ||= available_shipping_methods(:front_end).collect do |ship_method|
+      next unless cost = ship_method.calculator.compute(self)
       { :id => ship_method.id,
         :shipping_method => ship_method,
         :name => ship_method.name,
-        :cost => ship_method.calculator.compute(self)
+        :cost => cost
       }
-    end.sort_by{|r| r[:cost]}
+    end.compact.sort_by{|r| r[:cost]}
   end
 
   def payment
@@ -383,6 +397,16 @@ class Order < ActiveRecord::Base
       "partial"
     end
     self.shipment_state = "backorder" if backordered?
+
+    if old_shipment_state = self.changed_attributes["shipment_state"]
+      self.state_events.create({
+        :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
+      })
+    end
+
   end
 
   # Updates the +payment_state+ attribute according to the following logic:
@@ -402,6 +426,15 @@ class Order < ActiveRecord::Base
     else
       self.payment_state = "paid"
     end
+
+    if old_payment_state = self.changed_attributes["payment_state"]
+      self.state_events.create({
+        :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
+      })
+    end
   end
 
   # Updates the following Order total values:
@@ -433,6 +466,12 @@ class Order < ActiveRecord::Base
     return true unless new_record? or state == 'cart'
   end
 
+  def has_available_shipment
+    return unless :address == state_name.to_sym
+    return unless ship_address && ship_address.valid?
+    errors.add(:base, :no_shipping_methods_available) if available_shipping_methods.empty?
+  end
+
   def after_cancel
     # TODO: make_shipments_pending
     # TODO: restock_inventory

data/app/models/payment.rb

@@ -6,26 +6,19 @@ class Payment < ActiveRecord::Base
   has_many :offsets, :class_name => 'Payment', :foreign_key => 'source_id', :conditions => "source_type = 'Payment' AND amount < 0 AND state = 'completed'"
   has_many :log_entries, :as => :source
 
-  after_save :create_payment_profile, :if => :payment_profiles_supported?
+  after_save :create_payment_profile, :if => :profiles_supported?
 
   # update the order totals, etc.
   after_save :update_order
 
-  #after_save :check_payments
-  #after_destroy :check_payments
-
   accepts_nested_attributes_for :source
 
-  #validate :amount_is_valid_for_outstanding_balance_or_credit
-  #validates :payment_method, :presence => true, :if => Proc.new { |payable| payable.is_a? Checkout }
-
   scope :from_creditcard, where(:source_type => 'Creditcard')
   scope :with_state, lambda {|s| where(:state => s)}
   scope :completed, with_state('completed')
   scope :pending, with_state('pending')
   scope :failed, with_state('failed')
 
-
   # order state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
   state_machine :initial => 'checkout' do
     # With card payments, happens before purchase or authorization happens
@@ -93,26 +86,6 @@ class Payment < ActiveRecord::Base
 
   private
 
-    # def check_payments
-    #   return unless order and order.complete?
-    #   #sorting by created_at.to_f to ensure millisecond percsision, plus ID - just in case
-    #   events = order.state_events.sort_by { |e| [e.created_at.to_f, e.id] }.reverse
-    #   # TODO: think the below implementation will need replacing
-    #   # if order.returnable_units.nil? && order.return_authorizations.size >0
-    #   #   order.return!
-    #   # elsif events.present? and %w(over_paid under_paid).include?(events.first.name)
-    #   #   events.each do |event|
-    #   #     if %w(shipped paid new).include?(event.previous_state)
-    #   #       order.pay!
-    #   #       order.update_attribute("state", event.previous_state) if %w(shipped returned).include?(event.previous_state)
-    #   #       return
-    #   #     end
-    #   #   end
-    #   # elsif order.payment_total >= order.total
-    #   #   order.pay!
-    #   # end
-    # end
-
     def amount_is_valid_for_outstanding_balance_or_credit
       return unless order
       if amount != order.outstanding_balance
@@ -120,13 +93,13 @@ class Payment < ActiveRecord::Base
       end
     end
 
-    def payment_profiles_supported?
-      source && source.respond_to?(:payment_gateway) && source.payment_gateway && source.payment_gateway.payment_profiles_supported?
+    def profiles_supported?
+      payment_method.respond_to?(:payment_profiles_supported?) && payment_method.payment_profiles_supported?
     end
 
     def create_payment_profile
-      return unless payment_profiles_supported? and source.number and !source.has_payment_profile?
-      source.payment_gateway.create_profile(self)
+      return unless source.is_a?(Creditcard) && source.number && !source.has_payment_profile?
+      payment_method.create_profile(self)
     rescue ActiveMerchant::ConnectionError => e
       gateway_error I18n.t(:unable_to_connect_to_gateway)
     end

data/app/models/preference.rb

@@ -1,7 +1,7 @@
 # Represents a preferred value for a particular preference on a model.
-# 
+#
 # == Targeted preferences
-# 
+#
 # In addition to simple named preferences, preferences can also be targeted for
 # a particular record.  For example, a User may have a preferred color for a
 # particular Car.  In this case, the +owner+ is the User, the +preference+ is
@@ -10,10 +10,10 @@
 class Preference < ActiveRecord::Base
   belongs_to  :owner, :polymorphic => true
   belongs_to  :group, :polymorphic => true
-  
+
   validates :name, :owner_id, :owner_type, :presence => true
   validates :group_type, :presence => true, :if => :group_id?
-  
+
   class << self
     # Splits the given group into its corresponding id and type
     def split_group(group = nil)
@@ -25,19 +25,19 @@ class Preference < ActiveRecord::Base
       return group_id, group_type
     end
   end
-  
+
   # The definition for the attribute
   def definition
     owner.preference_definitions[name] unless owner_type.blank?
   end
-  
+
   # Typecasts the value depending on the preference definition's declared type
   def value
     value = read_attribute(:value)
     value = definition.type_cast(value) if definition
     value
   end
-  
+
   # Only searches for the group record if the group id is specified
   def group_with_optional_lookup
     group_id ? group_without_optional_lookup : group_type

data/app/models/product.rb

@@ -43,7 +43,8 @@ class Product < ActiveRecord::Base
   after_save :save_master
 
   has_many :variants,
-    :conditions => ["variants.is_master = ? AND variants.deleted_at IS NULL", false]
+    :conditions => ["variants.is_master = ? AND variants.deleted_at IS NULL", false],
+    :order => 'variants.position ASC'
 
 
   has_many :variants_including_master,
@@ -51,9 +52,15 @@ class Product < ActiveRecord::Base
     :conditions => ["variants.deleted_at IS NULL"],
     :dependent => :destroy
 
+  has_many :variants_with_only_master,
+    :class_name => 'Variant',
+    :conditions => ["variants.deleted_at IS NULL AND variants.is_master = ?", true],
+    :dependent => :destroy
+
+
   validates :name, :price, :permalink, :presence => true
 
-  accepts_nested_attributes_for :product_properties, :allow_destroy => true, :reject_if => lambda { |pp| pp[:property_name].blank? } 
+  accepts_nested_attributes_for :product_properties, :allow_destroy => true, :reject_if => lambda { |pp| pp[:property_name].blank? }
 
   make_permalink
 
@@ -64,18 +71,26 @@ class Product < ActiveRecord::Base
   #RAILS3 TODO -  scopes are duplicated here and in scopres/product.rb - can we DRY it up?
   # default product scope only lists available and non-deleted products
   scope :not_deleted,     where("products.deleted_at is NULL")
+
   scope :available,       lambda { |*on| where("products.available_on <= ?", on.first || Time.zone.now ) }
-  scope :active,          not_deleted.available #RAILS 3 TODO - this scope doesn't match the original 2.3.x version, needs attention (but it works)
-  scope :on_hand,         where("products.count_on_hand > 0")
 
+  #RAILS 3 TODO - this scope doesn't match the original 2.3.x version, needs attention (but it works)
+  scope :active,          lambda{ not_deleted.available }
 
+  scope :on_hand,         where("products.count_on_hand > 0")
 
   if (ActiveRecord::Base.connection.adapter_name == 'PostgreSQL')
-    scope :group_by_products_id, { :group => "products." + Product.column_names.join(", products.") } if ActiveRecord::Base.connection.tables.include?("products")
+    if ActiveRecord::Base.connection.tables.include?("products")
+      scope :group_by_products_id, { :group => "products." + Product.column_names.join(", products.") }
+    end
   else
     scope :group_by_products_id, { :group => "products.id" }
   end
+  search_methods :group_by_products_id
+
+  scope :id_equals, lambda { |input_id| where("products.id = ?", input_id) }
 
+  scope :taxons_name_eq, lambda { |name| joins(:taxons).where("taxons.name = ?", name) }
 
   # ----------------------------------------------------------------------------------------------------------
   #
@@ -108,7 +123,7 @@ class Product < ActiveRecord::Base
   # ----------------------------------------------------------------------------------------------------------
 
   def to_param
-    return permalink unless permalink.blank?
+    return permalink if permalink.present?
     name.to_url
   end
 
@@ -148,7 +163,7 @@ class Product < ActiveRecord::Base
   end
 
   def add_properties_and_option_types_from_prototype
-    if prototype_id and prototype = Prototype.find_by_id(prototype_id)
+    if prototype_id && prototype = Prototype.find_by_id(prototype_id)
       prototype.properties.each do |property|
         product_properties.create(:property => property)
       end

data/app/models/product_group.rb

@@ -24,10 +24,10 @@
 # without retriving all records.
 #
 # ProductGroup operates on named scopes defined for product in Scopes::Product,
-# or generated automatically by Searchlogic
+# or generated automatically by meta_search
 #
 class ProductGroup < ActiveRecord::Base
-  validates :name, :presence => true
+  validates :name, :presence => true # TODO ensure that this field is defined as not_null
   validates_associated :product_scopes
 
   before_save :set_permalink
@@ -36,7 +36,7 @@ class ProductGroup < ActiveRecord::Base
   has_and_belongs_to_many :cached_products, :class_name => "Product"
   # name
   has_many :product_scopes
-  accepts_nested_attributes_for :product_scopes 
+  accepts_nested_attributes_for :product_scopes
 
   # Testing utility: creates new *ProductGroup* from search permalink url.
   # Follows conventions for accessing PGs from URLs, as decoded in routes
@@ -58,7 +58,7 @@ class ProductGroup < ActiveRecord::Base
     end
     taxon = taxons && taxons.split("/").last
     pg.add_scope("in_taxon", taxon) if taxon
-    
+
     pg
   end
 
@@ -75,7 +75,7 @@ class ProductGroup < ActiveRecord::Base
   def from_route(attrs)
     self.order_scope = attrs.pop if attrs.length % 2 == 1
     attrs.each_slice(2) do |scope|
-      next unless Product.condition?(scope.first)
+      next unless Product.respond_to?(scope.first)
       add_scope(scope.first, scope.last.split(","))
     end
     self
@@ -85,19 +85,15 @@ class ProductGroup < ActiveRecord::Base
     search_hash.each_pair do |scope_name, scope_attribute|
       add_scope(scope_name, scope_attribute)
     end
-    
+
     self
   end
 
   def add_scope(scope_name, arguments=[])
-    if scope_name.to_s !~ /eval|send|system|[^a-z0-9_!?]/
-      self.product_scopes << ProductScope.new({
-          :name => scope_name.to_s,
-          :arguments => [*arguments]
-        })
-    else
-      raise ArgumentError.new("'#{scope_name}` can't be used as scope")
-    end
+    self.product_scopes << ProductScope.new({
+        :name => scope_name.to_s,
+        :arguments => [*arguments]
+      })
     self
   end
 
@@ -106,15 +102,14 @@ class ProductGroup < ActiveRecord::Base
     # from first nested_scope so we have to apply ordering FIRST.
     # see #2253 on rails LH
     base_product_scope = scopish
-    if use_order && !self.order_scope.blank? && Product.condition?(self.order_scope)
+    if use_order && !self.order_scope.blank? && Product.respond_to?(self.order_scope.intern)
       base_product_scope = base_product_scope.send(self.order_scope)
     end
 
-    return self.product_scopes.reject {|s|
-             s.is_ordering?
-           }.inject(base_product_scope){|result, scope|
-             scope.apply_on(result)
-           }
+    return self.product_scopes.reject {|s| s.is_ordering? }.inject(base_product_scope) do |result, scope|
+      scope.apply_on(result)
+    end
+
   end
 
   # returns chain of named scopes generated from order scope and product scopes.
@@ -131,9 +126,9 @@ class ProductGroup < ActiveRecord::Base
     elsif !use_order
       cached_group
     else
-      product_scopes.select {|s| 
+      product_scopes.select {|s|
         s.is_ordering?
-      }.inject(cached_group) {|res,order| 
+      }.inject(cached_group) {|res,order|
         order.apply_on(res)
       }
     end
@@ -160,7 +155,7 @@ class ProductGroup < ActiveRecord::Base
         [ps.name, ps.arguments.join(",")]
       }.flatten.join('/')
       result+= self.order_scope if self.order_scope
-    
+
       result
     else
       name.to_url
@@ -170,7 +165,7 @@ class ProductGroup < ActiveRecord::Base
   def set_permalink
     self.permalink = self.name.to_url
   end
-  
+
   def update_memberships
     # wipe everything directly to avoid expensive in-rails sorting
     ActiveRecord::Base.connection.execute "DELETE FROM product_groups_products WHERE product_group_id = #{self.id}"
@@ -188,18 +183,19 @@ class ProductGroup < ActiveRecord::Base
   def to_s
     "<ProductGroup" + (id && "[#{id}]").to_s + ":'#{to_url}'>"
   end
-  
+
   def order_scope
     if scope = product_scopes.detect {|s| s.is_ordering?}
       scope.name
     end
   end
+
   def order_scope=(scope_name)
     if scope = product_scopes.detect {|s| s.is_ordering?}
       scope.update_attribute(:name, scope_name)
     else
       self.product_scopes.build(:name => scope_name, :arguments => [])
-    end    
+    end
   end
 
   # Build a new product group with a scope to filter by specified products