spree_core 3.1.14 → 3.2.0.rc1

data/app/models/spree/order.rb

@@ -236,11 +236,6 @@ module Spree
       updater.update
     end
 
-    def update!
-      warn "`update!` is deprecated as it conflicts with update! method of rails. Use `update_with_updater!` instead."
-      update_with_updater!
-    end
-
     def merger
       @merger ||= Spree::OrderMerger.new(self)
     end
@@ -272,8 +267,8 @@ module Spree
       self.user           = user
       self.email          = user.email if override_email
       self.created_by   ||= user
-      self.bill_address ||= user.bill_address.try(:clone)
-      self.ship_address ||= user.ship_address.try(:clone)
+      self.bill_address ||= user.bill_address
+      self.ship_address ||= user.ship_address
 
       changes = slice(:user_id, :email, :created_by_id, :bill_address_id, :ship_address_id)
 
@@ -405,7 +400,7 @@ module Spree
     end
 
     def available_payment_methods
-      @available_payment_methods ||= PaymentMethod.available_on_front_end
+      @available_payment_methods ||= collect_payment_methods
     end
 
     def insufficient_stock_lines
@@ -481,7 +476,6 @@ module Spree
       Spree::Promotion.order_activatable?(self)
     end
 
-
     def shipped?
       %w(partial shipped).include?(shipment_state)
     end
@@ -489,6 +483,11 @@ module Spree
     def create_proposed_shipments
       all_adjustments.shipping.delete_all
       shipments.destroy_all
+
+      # Inventory Units which are not associated to any shipment (unshippable)
+      # and are not returned or shipped should be deleted
+      inventory_units.on_hand_or_backordered.delete_all
+
       self.shipments = Spree::Stock::Coordinator.new(self).shipments
     end
 
@@ -608,22 +607,6 @@ module Spree
     end
     alias_method :fully_discounted, :fully_discounted?
 
-    def payments_attributes=(attributes)
-      validate_payments_attributes(attributes)
-      super(attributes)
-    end
-
-    def validate_payments_attributes(attributes)
-      # Ensure the payment methods specified are allowed for this user
-      payment_methods = Spree::PaymentMethod.where(id: available_payment_methods.map(&:id))
-      attributes.each do |payment_attributes|
-        payment_method_id = payment_attributes[:payment_method_id]
-
-        # raise RecordNotFound unless it is an allowed payment method
-        payment_methods.find(payment_method_id) if payment_method_id
-      end
-    end
-
     private
 
     def link_by_email
@@ -681,5 +664,9 @@ module Spree
     def create_token
       self.guest_token ||= generate_guest_token
     end
+
+    def collect_payment_methods
+      PaymentMethod.available_on_front_end.select { |pm| pm.available_for_order?(self) }
+    end
   end
 end

data/app/models/spree/order_contents.rb

@@ -53,17 +53,16 @@ module Spree
     end
 
     def filter_order_items(params)
-      filtered_params = params.symbolize_keys
-      return filtered_params if filtered_params[:line_items_attributes].nil? || filtered_params[:line_items_attributes][:id]
+      return params if params[:line_items_attributes].nil? || params[:line_items_attributes][:id]
 
       line_item_ids = order.line_items.pluck(:id)
 
       params[:line_items_attributes].each_pair do |id, value|
         unless line_item_ids.include?(value[:id].to_i) || value[:variant_id].present?
-          filtered_params[:line_items_attributes].delete(id)
+          params[:line_items_attributes].delete(id)
         end
       end
-      filtered_params
+      params
     end
 
     def order_updater
@@ -82,8 +81,10 @@ module Spree
         line_item.quantity += quantity.to_i
         line_item.currency = currency unless currency.nil?
       else
-        opts = { currency: order.currency }.merge ActionController::Parameters.new(options).
-                                            permit(PermittedAttributes.line_item_attributes)
+        opts = ActionController::Parameters.new(options.to_h).
+               permit(PermittedAttributes.line_item_attributes).to_h.
+               merge( { currency: order.currency } )
+
         line_item = order.line_items.new(quantity: quantity,
                                           variant: variant,
                                           options: opts)

data/app/models/spree/order_inventory.rb

@@ -25,6 +25,8 @@ module Spree
 
           shipment = determine_target_shipment unless shipment
           add_to_shipment(shipment, quantity)
+        elsif inventory_units.size == line_item.quantity && !line_item.changed?
+          remove(inventory_units, shipment)
         elsif inventory_units.size > line_item.quantity
           remove(inventory_units, shipment)
         end
@@ -32,8 +34,9 @@ module Spree
     end
 
     private
+
       def remove(item_units, shipment = nil)
-        quantity = item_units.size - line_item.quantity
+        quantity = set_quantity_to_remove(item_units)
 
         if shipment.present?
           remove_from_shipment(shipment, quantity)
@@ -45,6 +48,14 @@ module Spree
         end
       end
 
+      def set_quantity_to_remove(item_units)
+        if (item_units.size - line_item.quantity).zero?
+          line_item.quantity
+        else
+          item_units.size - line_item.quantity
+        end
+      end
+
       # Returns either one of the shipment:
       #
       # first unshipped that already includes this variant

data/app/models/spree/order_updater.rb

@@ -15,7 +15,6 @@ module Spree
     # object with callbacks (otherwise you will end up in an infinite recursion as the
     # associations try to save and then in turn try to call +update!+ again.)
     def update
-      update_item_count
       update_totals
       if order.completed?
         update_payment_state
@@ -139,7 +138,7 @@ module Spree
           # will return nil if no shipments are found
           order.shipment_state = shipment_states.first
           # TODO inventory unit states?
-          # if order.shipment_state && order.inventory_units.where(:shipment_id => nil).exists?
+          # if order.shipment_state && order.inventory_units.where(shipment_id: nil).exists?
           #   shipments exist but there are unassigned inventory units
           #   order.shipment_state = 'partial'
           # end

data/app/models/spree/payment/processing.rb

@@ -29,7 +29,7 @@ module Spree
       # a new pending payment record for the remaining amount to capture later.
       def capture!(amount = nil)
         return true if completed?
-        amount ||= money.amount_in_cents
+        amount ||= money.money.cents
         started_processing!
         protect_from_connection_error do
           # Standard ActiveMerchant capture usage
@@ -115,7 +115,7 @@ module Spree
 
       def gateway_action(source, action, success_state)
         protect_from_connection_error do
-          response = payment_method.send(action, money.amount_in_cents,
+          response = payment_method.send(action, money.money.cents,
                                          source,
                                          gateway_options)
           handle_response(response, success_state, :failure)
@@ -143,7 +143,7 @@ module Spree
       end
 
       def record_response(response)
-        log_entries.create!(:details => response.to_yaml)
+        log_entries.create!(details: response.to_yaml)
       end
 
       def protect_from_connection_error

data/app/models/spree/payment_method.rb

@@ -5,7 +5,7 @@ module Spree
 
     DISPLAY = [:both, :front_end, :back_end].freeze
 
-    scope :active,                 -> { where(active: true) }
+    scope :active,                 -> { where(active: true).order(position: :asc) }
     scope :available,              -> { active.where(display_on: [:front_end, :back_end, :both]) }
     scope :available_on_front_end, -> { active.where(display_on: [:front_end, :both]) }
     scope :available_on_back_end,  -> { active.where(display_on: [:back_end, :both]) }
@@ -67,5 +67,11 @@ module Spree
     def store_credit?
       self.class == Spree::PaymentMethod::StoreCredit
     end
+
+    # Custom PaymentMethod/Gateway can redefine this method to check method
+    # availability for concrete order.
+    def available_for_order?(_order)
+      true
+    end
   end
 end

data/app/models/spree/preferences/store.rb

@@ -24,7 +24,7 @@ module Spree::Preferences
 
     def exist?(key)
       @cache.exist?(key) ||
-      should_persist? && Spree::Preference.where(:key => key).exists?
+      should_persist? && Spree::Preference.where(key: key).exists?
     end
 
     def get(key)
@@ -73,7 +73,7 @@ module Spree::Preferences
     def persist(cache_key, value)
       return unless should_persist?
 
-      preference = Spree::Preference.where(:key => cache_key).first_or_initialize
+      preference = Spree::Preference.where(key: cache_key).first_or_initialize
       preference.value = value
       preference.save
     end
@@ -86,7 +86,7 @@ module Spree::Preferences
     end
 
     def should_persist?
-      @persistence && ActiveRecord::Base.connected? && Spree::Preference.table_exists?
+      @persistence and Spree::Preference.table_exists?
     end
 
   end

data/app/models/spree/product/scopes.rb

@@ -39,34 +39,34 @@ module Spree
     add_simple_scopes simple_scopes
 
     add_search_scope :ascend_by_master_price do
-      joins(:master => :default_price).order("#{price_table_name}.amount ASC")
+      joins(master: :default_price).order("#{price_table_name}.amount ASC")
     end
 
     add_search_scope :descend_by_master_price do
-      joins(:master => :default_price).order("#{price_table_name}.amount DESC")
+      joins(master: :default_price).order("#{price_table_name}.amount DESC")
     end
 
     add_search_scope :price_between do |low, high|
-      joins(:master => :default_price).where(Price.table_name => { :amount => low..high })
+      joins(master: :default_price).where(Price.table_name => { amount: low..high })
     end
 
     add_search_scope :master_price_lte do |price|
-      joins(:master => :default_price).where("#{price_table_name}.amount <= ?", price)
+      joins(master: :default_price).where("#{price_table_name}.amount <= ?", price)
     end
 
     add_search_scope :master_price_gte do |price|
-      joins(:master => :default_price).where("#{price_table_name}.amount >= ?", price)
+      joins(master: :default_price).where("#{price_table_name}.amount >= ?", price)
     end
 
     # This scope selects products in taxon AND all its descendants
     # If you need products only within one taxon use
     #
-    #   Spree::Product.joins(:taxons).where(Taxon.table_name => { :id => taxon.id })
+    #   Spree::Product.joins(:taxons).where(Taxon.table_name => { id: taxon.id })
     #
     # If you're using count on the result of this scope, you must use the
     # `:distinct` option as well:
     #
-    #   Spree::Product.in_taxon(taxon).count(:distinct => true)
+    #   Spree::Product.in_taxon(taxon).count(distinct: true)
     #
     # This is so that the count query is distinct'd:
     #
@@ -162,8 +162,8 @@ module Spree
     # there is alternative faster and more elegant solution, it has small drawback though,
     # it doesn stack with other scopes :/
     #
-    # :joins => "LEFT OUTER JOIN (SELECT line_items.variant_id as vid, COUNT(*) as cnt FROM line_items GROUP BY line_items.variant_id) AS popularity_count ON variants.id = vid",
-    # :order => 'COALESCE(cnt, 0) DESC'
+    # joins: "LEFT OUTER JOIN (SELECT line_items.variant_id as vid, COUNT(*) as cnt FROM line_items GROUP BY line_items.variant_id) AS popularity_count ON variants.id = vid",
+    # order: 'COALESCE(cnt, 0) DESC'
     add_search_scope :descend_by_popularity do
       joins(:master).
       order(%Q{
@@ -186,23 +186,19 @@ module Spree
       where("#{Product.quoted_table_name}.deleted_at IS NULL or #{Product.quoted_table_name}.deleted_at >= ?", Time.zone.now)
     end
 
-    def self.not_discontinued(only_not_discontinued = true)
-      if only_not_discontinued != '0' && only_not_discontinued
-        where("#{Product.quoted_table_name}.discontinue_on IS NULL or #{Product.quoted_table_name}.discontinue_on >= ?", Time.zone.now)
-      else
-        all
-      end
+    add_search_scope :not_discontinued do
+      where("#{Product.quoted_table_name}.discontinue_on IS NULL or #{Product.quoted_table_name}.discontinue_on >= ?", Time.zone.now)
     end
-    search_scopes << :not_discontinued
+
     # Can't use add_search_scope for this as it needs a default argument
     def self.available(available_on = nil, currency = nil)
       available_on ||= Time.current
-      not_discontinued.joins(master: :prices).where("#{Product.quoted_table_name}.available_on <= ?", available_on).uniq
+      not_discontinued.joins(master: :prices).where("#{Product.quoted_table_name}.available_on <= ?", available_on).distinct
     end
     search_scopes << :available
 
     def self.active(currency = nil)
-      not_discontinued.available(nil, currency)
+      available(nil, currency)
     end
     search_scopes << :active
 
@@ -228,7 +224,7 @@ module Spree
       #
       # Don't allow sort_column, a variable coming from params,
       # to be anything but a column in the database
-      if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL' && !column_names.include?(sort_column)
+      if ApplicationRecord.connection.adapter_name == 'PostgreSQL' && !column_names.include?(sort_column)
         all
       else
         distinct
@@ -260,7 +256,7 @@ module Spree
         ids_or_records_or_names.flatten.map { |t|
           case t
           when Integer then Taxon.find_by(id: t)
-          when ActiveRecord::Base then t
+          when ApplicationRecord then t
           when String
             Taxon.find_by(name: t) ||
             Taxon.where("#{taxons}.permalink LIKE ? OR #{taxons}.permalink = ?", "%/#{t}/", "#{t}/").first

data/app/models/spree/product.rb

@@ -21,6 +21,7 @@
 module Spree
   class Product < Spree::Base
     extend FriendlyId
+    include ActsAsTaggable
     friendly_id :slug_candidates, use: :history
 
     acts_as_paranoid
@@ -115,7 +116,6 @@ module Spree
 
     self.whitelisted_ransackable_associations = %w[stores variants_including_master master variants]
     self.whitelisted_ransackable_attributes = %w[description name slug discontinue_on]
-    self.whitelisted_ransackable_scopes = %w[not_discontinued]
 
     # the master variant is not a member of the variants array
     def has_variants?
@@ -212,7 +212,7 @@ module Spree
     end
 
     def set_property(property_name, property_value, property_presentation = property_name)
-      ActiveRecord::Base.transaction do
+      ApplicationRecord.transaction do
         # Works around spree_i18n #301
         property = Property.create_with(presentation: property_presentation).find_or_create_by(name: property_name)
         product_property = ProductProperty.where(product: self, property: property).first_or_initialize
@@ -236,6 +236,14 @@ module Spree
       super || variants_including_master.with_deleted.find_by(is_master: true)
     end
 
+    def brand
+      taxons.joins(:taxonomy).find_by(spree_taxonomies: { name: Spree.t(:taxonomy_brands_name) })
+    end
+
+    def category
+      taxons.joins(:taxonomy).find_by(spree_taxonomies: { name: Spree.t(:taxonomy_categories_name) })
+    end
+
     private
 
     def add_associations_from_prototype
@@ -269,7 +277,7 @@ module Spree
           price: master.price
         )
       end
-      save
+      throw(:abort) unless save
     end
 
     def ensure_master

data/app/models/spree/promotion/actions/create_line_items.rb

@@ -5,7 +5,7 @@ module Spree
         has_many :promotion_action_line_items, foreign_key: :promotion_action_id
         accepts_nested_attributes_for :promotion_action_line_items
 
-        delegate :eligible?, :to => :promotion
+        delegate :eligible?, to: :promotion
 
         # Adds a line item to the Order if the promotion is eligible
         #
@@ -37,7 +37,7 @@ module Spree
         # needs to be manually removed from the order by the customer
         def perform(options = {})
           order = options[:order]
-          return unless self.eligible? order
+          return unless eligible? order
 
           action_taken = false
           promotion_action_line_items.each do |item|
@@ -50,12 +50,30 @@ module Spree
           action_taken
         end
 
+        # Called by promotion handler when a promotion is removed
+        # This will find any line item matching the ones defined in the PromotionAction
+        # and remove the same quantity as was added by the PromotionAction.
+        # Should help to prevent some of cases listed above the #perform method
+        def revert(options = {})
+          order = options[:order]
+          return if eligible?(order)
+
+          action_taken = false
+          promotion_action_line_items.each do |item|
+            line_item = order.find_line_item_by_variant(item.variant)
+            next unless line_item.present?
+            order.contents.remove(item.variant, (item.quantity || 1))
+            action_taken = true
+          end
+
+          action_taken
+        end
+
         # Checks that there's enough stock to add the line item to the order
         def item_available?(item)
           quantifier = Spree::Stock::Quantifier.new(item.variant)
           quantifier.can_supply? item.quantity
         end
-
       end
     end
   end

data/app/models/spree/promotion/rules/country.rb

@@ -0,0 +1,23 @@
+# A rule to limit a promotion based on shipment country.
+module Spree
+  class Promotion
+    module Rules
+      class Country < PromotionRule
+        preference :country_id, :integer
+
+        def applicable?(promotable)
+          promotable.is_a?(Spree::Order)
+        end
+
+        def eligible?(order, options = {})
+          country_id = options[:country_id] || order.ship_address.try(:country_id)
+          unless country_id.eql?(preferred_country_id || Spree::Country.default)
+            eligibility_errors.add(:base, eligibility_error_message(:wrong_country))
+          end
+
+          eligibility_errors.empty?
+        end
+      end
+    end
+  end
+end

data/app/models/spree/promotion/rules/option_value.rb

@@ -1,7 +1,20 @@
 module Spree
   class Promotion
     module Rules
+      module OptionValueWithNumerificationSupport
+        def preferred_eligible_values
+          values = super || {}
+          Hash[values.keys.map(&:to_i).zip(
+            values.values.map do |v|
+              (v.is_a?(Array) ? v : v.split(",")).map(&:to_i)
+            end
+          )]
+        end
+      end
+
       class OptionValue < PromotionRule
+        prepend OptionValueWithNumerificationSupport
+
         MATCH_POLICIES = %w(any)
         preference :match_policy, :string, default: MATCH_POLICIES.first
         preference :eligible_values, :hash
@@ -24,16 +37,6 @@ module Spree
           product_ids.include?(pid) && (value_ids(pid) - ovids).empty?
         end
 
-        def preferred_eligible_values_with_numerification
-          values = preferred_eligible_values_without_numerification || {}
-          Hash[values.keys.map(&:to_i).zip(
-            values.values.map do |v|
-              (v.is_a?(Array) ? v : v.split(",")).map(&:to_i)
-            end
-          )]
-        end
-        alias_method_chain :preferred_eligible_values, :numerification
-
         private
 
         def product_ids

data/app/models/spree/promotion/rules/taxon.rb

@@ -44,7 +44,7 @@ module Spree
 
         # All taxons in an order
         def order_taxons(order)
-          Spree::Taxon.joins(products: {variants_including_master: :line_items}).where(spree_line_items: {order_id: order.id}).uniq
+          Spree::Taxon.joins(products: {variants_including_master: :line_items}).where(spree_line_items: {order_id: order.id}).distinct
         end
 
         # ids of taxons rules and taxons rules children

data/app/models/spree/promotion.rb

@@ -24,13 +24,14 @@ module Spree
     validates :path, uniqueness: { allow_blank: true }
     validates :usage_limit, numericality: { greater_than: 0, allow_nil: true }
     validates :description, length: { maximum: 255 }, allow_blank: true
+    validate :expires_at_must_be_later_than_starts_at, if: -> { starts_at && expires_at }
 
     before_save :normalize_blank_values
 
     scope :coupons, -> { where.not(code: nil) }
     scope :advertised, -> { where(advertise: true) }
     scope :applied, lambda {
-      joins(<<-SQL).uniq
+      joins(<<-SQL).distinct
         INNER JOIN spree_order_promotions
         ON spree_order_promotions.promotion_id = #{table_name}.id
       SQL
@@ -82,6 +83,33 @@ module Spree
       action_taken
     end
 
+    # Called when a promotion is removed from the cart
+    def deactivate(payload)
+      order = payload[:order]
+      return unless self.class.order_activatable?(order)
+
+      payload[:promotion] = self
+
+      # Track results from actions to see if any action has been taken.
+      # Actions should return nil/false if no action has been taken.
+      # If an action returns true, then an action has been taken.
+      results = actions.map do |action|
+        action.revert(payload) if action.respond_to?(:revert)
+      end
+
+      # If an action has been taken, report back to whatever `d this promotion.
+      action_taken = results.include?(true)
+
+      if action_taken
+        # connect to the order
+        # create the join_table entry.
+        orders << order
+        save
+      end
+
+      action_taken
+    end
+
     # called anytime order.update_with_updater! happens
     def eligible?(promotable)
       return false if expired? || usage_limit_exceeded?(promotable) || blacklisted?(promotable)
@@ -194,5 +222,11 @@ module Spree
     def match_all?
       match_policy == 'all'
     end
+
+    def expires_at_must_be_later_than_starts_at
+      if expires_at < starts_at
+        errors.add(:expires_at, :invalid_date_range)
+      end
+    end
   end
 end

data/app/models/spree/promotion_handler/cart.rb

@@ -24,6 +24,8 @@ module Spree
         promotions.each do |promotion|
           if (line_item && promotion.eligible?(line_item)) || promotion.eligible?(order)
             promotion.activate(line_item: line_item, order: order)
+          else
+            promotion.deactivate(line_item: line_item, order: order)
           end
         end
       end
@@ -31,23 +33,7 @@ module Spree
       private
 
       def promotions
-        # AR cannot bind raw ASTs to prepared statements. There always must be a manager around.
-        # Also Postgresql requires an aliased table for `SELECT * FROM (subexpression) AS alias`.
-        # And Sqlite3 cannot work on outher parenthesis from `(left UNION right)`.
-        # So this construct makes both happy.
-        select = Arel::SelectManager.new(
-          Promotion,
-          Promotion.arel_table.create_table_alias(
-            order.promotions.active.union(Promotion.active.where(code: nil, path: nil)),
-            Promotion.table_name
-          ),
-        )
-        select.project(Arel.star)
-
-        Promotion.find_by_sql(
-          select,
-          order.promotions.bind_values
-        )
+        Promotion.find_by_sql("#{order.promotions.active.to_sql} UNION #{Promotion.active.where(code: nil, path: nil).to_sql}")
       end
     end
   end