spree_core 2.3.13 → 2.4.0.rc1

data/app/models/spree/stock/prioritizer.rb

@@ -1,10 +1,10 @@
 module Spree
   module Stock
     class Prioritizer
-      attr_reader :packages, :order
+      attr_reader :packages, :inventory_units
 
-      def initialize(order, packages, adjuster_class=Adjuster)
-        @order = order
+      def initialize(inventory_units, packages, adjuster_class=Adjuster)
+        @inventory_units = inventory_units
         @packages = packages
         @adjuster_class = adjuster_class
       end
@@ -18,8 +18,8 @@ module Spree
 
       private
       def adjust_packages
-        order.line_items.each do |line_item|
-          adjuster = @adjuster_class.new(line_item.variant, line_item.quantity, :on_hand)
+        inventory_units.each do |inventory_unit|
+          adjuster = @adjuster_class.new(inventory_unit, :on_hand)
 
           visit_packages(adjuster)
 
@@ -30,8 +30,8 @@ module Spree
 
       def visit_packages(adjuster)
         packages.each do |package|
-          item = package.find_item adjuster.variant, adjuster.status
-          adjuster.adjust(item) if item
+          item = package.find_item adjuster.inventory_unit, adjuster.status
+          adjuster.adjust(package) if item
         end
       end
 

data/app/models/spree/stock/splitter/base.rb

@@ -8,7 +8,7 @@ module Spree
           @packer = packer
           @next_splitter = next_splitter
         end
-        delegate :stock_location, :order, to: :packer
+        delegate :stock_location, to: :packer
 
         def split(packages)
           return_next(packages)
@@ -20,7 +20,7 @@ module Spree
         end
 
         def build_package(contents=[])
-          Spree::Stock::Package.new(stock_location, order, contents)
+          Spree::Stock::Package.new(stock_location, contents)
         end
       end
     end

data/app/models/spree/stock_item.rb

@@ -2,25 +2,19 @@ module Spree
   class StockItem < Spree::Base
     acts_as_paranoid
 
-    belongs_to :stock_location, class_name: 'Spree::StockLocation', inverse_of: :stock_items
+    belongs_to :stock_location, class_name: 'Spree::StockLocation'
     belongs_to :variant, class_name: 'Spree::Variant', inverse_of: :stock_items
     has_many :stock_movements, inverse_of: :stock_item
 
     validates_presence_of :stock_location, :variant
     validates_uniqueness_of :variant_id, scope: [:stock_location_id, :deleted_at]
-
-    validates_numericality_of :count_on_hand,
-                              greater_than_or_equal_to: 0,
-                              less_than_or_equal_to: 2**31 - 1,
-                              only_integer: true, if: :verify_count_on_hand?
+    validates :count_on_hand, numericality: { greater_than_or_equal_to: 0 }, if: :verify_count_on_hand?
 
     delegate :weight, :should_track_inventory?, to: :variant
 
     after_save :conditional_variant_touch, if: :changed?
     after_touch { variant.touch }
 
-    self.whitelisted_ransackable_attributes = ['count_on_hand', 'stock_location_id']
-
     def backordered_inventory_units
       Spree::InventoryUnit.backordered_for_stock_item(self)
     end
@@ -83,7 +77,10 @@ module Spree
       end
 
       def conditional_variant_touch
-        if !Spree::Config.binary_inventory_cache || (count_on_hand_changed? && count_on_hand_change.any?(&:zero?))
+        # the variant_id changes from nil when a new stock location is added
+        stock_changed = (count_on_hand_changed? && count_on_hand_change.any?(&:zero?)) || variant_id_changed?
+
+        if !Spree::Config.binary_inventory_cache || stock_changed
           variant.touch
         end
       end

data/app/models/spree/stock_location.rb

@@ -1,7 +1,7 @@
 module Spree
   class StockLocation < Spree::Base
     has_many :shipments
-    has_many :stock_items, dependent: :delete_all, inverse_of: :stock_location
+    has_many :stock_items, dependent: :delete_all
     has_many :stock_movements, through: :stock_items
 
     belongs_to :state, class_name: 'Spree::State'
@@ -10,13 +10,15 @@ module Spree
     validates_presence_of :name
 
     scope :active, -> { where(active: true) }
+    scope :order_default, -> { order(default: :desc, name: :asc) }
 
     after_create :create_stock_items, :if => "self.propagate_all_variants?"
+    after_save :ensure_one_default
 
     def state_text
       state.try(:abbr) || state.try(:name) || state_name
     end
-
+    
     # Wrapper for creating a new stock item respecting the backorderable config
     def propagate_variant(variant)
       self.stock_items.create!(variant: variant, backorderable: self.backorderable_default)
@@ -29,31 +31,12 @@ module Spree
       self.stock_item(variant) || propagate_variant(variant)
     end
 
-    # Returns an instance of StockItem for the variant id.
-    #
-    # @param variant_id [String] The id of a variant.
-    #
-    # @return [StockItem] Corresponding StockItem for the StockLocation's variant.
-    def stock_item(variant_id)
-      stock_items.where(variant_id: variant_id).order(:id).first
+    def stock_item(variant)
+      stock_items.where(variant_id: variant).order(:id).first
     end
 
-    # Attempts to look up StockItem for the variant, and creates one if not found.
-    # This method accepts an id or instance of the variant since it is used in
-    # multiple ways. Other methods in this model attempt to pass a variant,
-    # but controller actions can pass just the variant id as a parameter.
-    #
-    # @param variant_or_id [Variant|String] Variant instance or string id of a variant.
-    #
-    # @return [StockItem] Corresponding StockItem for the StockLocation's variant.
-    def stock_item_or_create(variant_or_id)
-      vid = if variant_or_id.is_a?(Variant)
-        variant_or_id.id
-      else
-        ActiveSupport::Deprecation.warn "Passing a Variant ID is deprecated, and will be removed in Spree 3. Please pass a variant instance instead.", caller
-        variant_or_id
-      end
-      stock_item(vid) || stock_items.create(variant_id: vid)
+    def stock_item_or_create(variant)
+      stock_item(variant) || stock_items.create(variant: variant)
     end
 
     def count_on_hand(variant)
@@ -107,5 +90,14 @@ module Spree
       def create_stock_items
         Variant.find_each { |variant| self.propagate_variant(variant) }
       end
+
+      def ensure_one_default
+        if self.default
+          StockLocation.where(default: true).where.not(id: self.id).each do |stock_location|
+            stock_location.default = false
+            stock_location.save!
+          end
+        end
+      end
   end
 end

data/app/models/spree/stock_movement.rb

@@ -6,17 +6,10 @@ module Spree
     after_create :update_stock_item_quantity
 
     validates :stock_item, presence: true
-    validates :quantity, presence: true, numericality: {
-                 greater_than_or_equal_to: -2**31,
-                 less_than_or_equal_to: 2**31-1,
-                 only_integer: true,
-                 allow_nil: true
-              }
+    validates :quantity, presence: true
 
     scope :recent, -> { order('created_at DESC') }
 
-    self.whitelisted_ransackable_attributes = ['quantity']
-
     def readonly?
       !new_record?
     end

data/app/models/spree/stock_transfer.rb

@@ -7,8 +7,6 @@ module Spree
 
     make_permalink field: :number, prefix: 'T'
 
-    self.whitelisted_ransackable_attributes = %w[reference source_location_id destination_location_id closed_at created_at number]
-
     def to_param
       number
     end

data/app/models/spree/store.rb

@@ -1,7 +1,7 @@
 module Spree
   class Store < Spree::Base
 
-    validates :code, presence: true, uniqueness: { allow_blank: true }
+    validates :code, presence: true, uniqueness: true
     validates :name, presence: true
     validates :url, presence: true
     validates :mail_from_address, presence: true

data/app/models/spree/tax_category.rb

@@ -1,9 +1,9 @@
 module Spree
   class TaxCategory < Spree::Base
     acts_as_paranoid
-    validates :name, presence: true, uniqueness: { scope: :deleted_at, allow_blank: true }
+    validates :name, presence: true, uniqueness: { scope: :deleted_at }
 
-    has_many :tax_rates, dependent: :destroy, inverse_of: :tax_category
+    has_many :tax_rates, dependent: :destroy
 
     before_save :set_default_category
 

data/app/models/spree/tax_rate.rb

@@ -11,15 +11,10 @@ end
 module Spree
   class TaxRate < Spree::Base
     acts_as_paranoid
-
-    # Need to deal with adjustments before calculator is destroyed.
-    before_destroy :deals_with_adjustments_for_deleted_source
-
-    include Spree::Core::CalculatedAdjustments
-    include Spree::Core::AdjustmentSource
-
-    belongs_to :zone, class_name: "Spree::Zone", inverse_of: :tax_rates
-    belongs_to :tax_category, class_name: "Spree::TaxCategory", inverse_of: :tax_rates
+    include Spree::CalculatedAdjustments
+    include Spree::AdjustmentSource
+    belongs_to :zone, class_name: "Spree::Zone"
+    belongs_to :tax_category, class_name: "Spree::TaxCategory"
 
     has_many :adjustments, as: :source
 
@@ -27,6 +22,8 @@ module Spree
     validates :tax_category_id, presence: true
     validates_with DefaultTaxZoneValidator
 
+    before_destroy :deals_with_adjustments_for_deleted_source
+
     scope :by_zone, ->(zone) { where(zone_id: zone) }
 
     # Gets the array of TaxRates appropriate for the specified order
@@ -61,16 +58,17 @@ module Spree
     # correct rate amounts in the future. For example:
     # https://github.com/spree/spree/issues/4318#issuecomment-34723428
     def self.store_pre_tax_amount(item, rates)
-      if rates.any? { |r| r.included_in_price }
-        case item
-        when Spree::LineItem
-          item_amount = item.discounted_amount
-        when Spree::Shipment
-          item_amount = item.discounted_cost
+      pre_tax_amount = case item
+        when Spree::LineItem then item.discounted_amount
+        when Spree::Shipment then item.discounted_cost
         end
-        pre_tax_amount = item_amount / (1 + rates.map(&:amount).sum)
-        item.update_column(:pre_tax_amount, pre_tax_amount)
+
+      included_rates = rates.select(&:included_in_price)
+      if included_rates.any?
+        pre_tax_amount /= (1 + included_rates.map(&:amount).sum)
       end
+
+      item.update_column(:pre_tax_amount, pre_tax_amount)
     end
 
     # This method is best described by the documentation on #potentially_applicable?
@@ -78,11 +76,7 @@ module Spree
       rates = self.match(order_tax_zone)
       tax_categories = rates.map(&:tax_category)
       relevant_items, non_relevant_items = items.partition { |item| tax_categories.include?(item.tax_category) }
-
-      if relevant_items.present?
-        Spree::Adjustment.where(adjustable: relevant_items).tax.destroy_all # using destroy_all to ensure adjustment destroy callback fires.
-      end
-
+      Spree::Adjustment.where(adjustable: relevant_items).tax.destroy_all # using destroy_all to ensure adjustment destroy callback fires.
       relevant_items.each do |item|
         relevant_rates = rates.select { |rate| rate.tax_category == item.tax_category }
         store_pre_tax_amount(item, relevant_rates)

data/app/models/spree/taxon.rb

@@ -20,7 +20,7 @@ module Spree
       default_url: '/assets/default_taxon.png'
 
     validates_attachment :icon,
-      content_type: { content_type: ["image/jpg", "image/jpeg", "image/png", "image/gif"] }
+      content_type: { content_type: ["image/jpg", "image/jpeg", "image/png"] }
 
     # indicate which filters should be used for a taxon
     # this method should be customized to your own site

data/app/models/spree/variant.rb

@@ -9,7 +9,7 @@ module Spree
                         :shipping_category_id, :meta_description, :meta_keywords,
                         :shipping_category
 
-    has_many :inventory_units, inverse_of: :variant
+    has_many :inventory_units
     has_many :line_items, inverse_of: :variant
     has_many :orders, through: :line_items
 
@@ -23,8 +23,7 @@ module Spree
     has_one :default_price,
       -> { where currency: Spree::Config[:currency] },
       class_name: 'Spree::Price',
-      dependent: :destroy,
-      inverse_of: :variant
+      dependent: :destroy
 
     delegate_belongs_to :default_price, :display_price, :display_amount, :price, :price=, :currency
 
@@ -33,25 +32,19 @@ module Spree
       dependent: :destroy,
       inverse_of: :variant
 
-    before_validation :set_cost_currency
-
     validate :check_price
-
     validates :cost_price, numericality: { greater_than_or_equal_to: 0, allow_nil: true }
-    validates :price,      numericality: { greater_than_or_equal_to: 0, allow_nil: true }
+    validates :price, numericality: { greater_than_or_equal_to: 0 }
     validates_uniqueness_of :sku, allow_blank: true, conditions: -> { where(deleted_at: nil) }
 
+    before_validation :set_cost_currency
     after_save :save_default_price
-
     after_create :create_stock_items
     after_create :set_position
-    after_create :set_master_out_of_stock, unless: :is_master?
+    after_create :set_master_out_of_stock, :unless => :is_master?
 
     after_touch :clear_in_stock_cache
 
-    self.whitelisted_ransackable_associations = %w[option_values product prices default_price]
-    self.whitelisted_ransackable_attributes = %w[weight sku]
-
     def self.active(currency = nil)
       joins(:prices).where(deleted_at: nil).where('spree_prices.currency' => currency || Spree::Config[:currency]).where('spree_prices.amount IS NOT NULL')
     end
@@ -65,11 +58,7 @@ module Spree
     end
 
     def cost_price=(price)
-      self[:cost_price] = Spree::LocalizedNumber.parse(price) if price.present?
-    end
-
-    def weight=(weight)
-      self[:weight] = Spree::LocalizedNumber.parse(weight) if weight.present?
+      self[:cost_price] = parse_price(price) if price.present?
     end
 
     # returns number of units currently on backorder for this variant.
@@ -77,10 +66,6 @@ module Spree
       inventory_units.with_state('backordered').size
     end
 
-    def is_backorderable?
-      Spree::Stock::Quantifier.new(self).backorderable?
-    end
-
     def options_text
       values = self.option_values.sort do |a, b|
         a.option_type.position <=> b.option_type.position
@@ -163,6 +148,32 @@ module Spree
       price_in(currency).try(:amount)
     end
 
+    def price_modifier_amount_in(currency, options = {})
+      return 0 unless options.present?
+
+      options.keys.map { |key|
+        m = "#{key}_price_modifier_amount_in".to_sym
+        if self.respond_to? m
+          self.send(m, currency, options[key])
+        else
+          0
+        end
+      }.sum
+    end
+
+    def price_modifier_amount(options = {})
+      return 0 unless options.present?
+
+      options.keys.map { |key|
+        m = "#{options[key]}_price_modifier_amount".to_sym
+        if self.respond_to? m
+          self.send(m, options[key]) 
+        else
+          0
+        end
+      }.sum
+    end
+
     def name_and_sku
       "#{name} - #{sku}"
     end
@@ -192,6 +203,17 @@ module Spree
     end
 
     private
+      # strips all non-price-like characters from the price, taking into account locale settings
+      def parse_price(price)
+        return price unless price.is_a?(String)
+
+        separator, delimiter = I18n.t([:'number.currency.format.separator', :'number.currency.format.delimiter'])
+        non_price_characters = /[^0-9\-#{separator}]/
+        price.gsub!(non_price_characters, '') # strip everything else first
+        price.gsub!(separator, '.') unless separator == '.' # then replace the locale-specific decimal separator with the standard separator if necessary
+
+        price.to_d
+      end
 
       def set_master_out_of_stock
         if product.master && product.master.in_stock?
@@ -225,8 +247,8 @@ module Spree
       end
 
       def create_stock_items
-        StockLocation.all.each do |stock_location|
-          stock_location.propagate_variant(self) if stock_location.propagate_all_variants?
+        StockLocation.where(propagate_all_variants: true).each do |stock_location|
+          stock_location.propagate_variant(self)
         end
       end
 

data/app/models/spree/zone.rb

@@ -1,18 +1,16 @@
 module Spree
   class Zone < Spree::Base
-    has_many :zone_members, dependent: :destroy, class_name: "Spree::ZoneMember", inverse_of: :zone
-    has_many :tax_rates, dependent: :destroy, inverse_of: :zone
+    has_many :zone_members, dependent: :destroy, class_name: "Spree::ZoneMember"
+    has_many :tax_rates, dependent: :destroy
     has_and_belongs_to_many :shipping_methods, :join_table => 'spree_shipping_methods_zones'
 
-    validates :name, presence: true, uniqueness: { allow_blank: true }
+    validates :name, presence: true, uniqueness: true
     after_save :remove_defunct_members
     after_save :remove_previous_default
 
     alias :members :zone_members
     accepts_nested_attributes_for :zone_members, allow_destroy: true, reject_if: proc { |a| a['zoneable_id'].blank? }
 
-    self.whitelisted_ransackable_attributes = ['description']
-
     def self.default_tax
       where(default_tax: true).first
     end
@@ -94,11 +92,23 @@ module Spree
     end
 
     def country_ids=(ids)
-      set_zone_members(ids, 'Spree::Country')
+      zone_members.destroy_all
+      ids.reject{ |id| id.blank? }.map do |id|
+        member = ZoneMember.new
+        member.zoneable_type = 'Spree::Country'
+        member.zoneable_id = id
+        members << member
+      end
     end
 
     def state_ids=(ids)
-      set_zone_members(ids, 'Spree::State')
+      zone_members.destroy_all
+      ids.reject{ |id| id.blank? }.map do |id|
+        member = ZoneMember.new
+        member.zoneable_type = 'Spree::State'
+        member.zoneable_id = id
+        members << member
+      end
     end
 
     # Indicates whether the specified zone falls entirely within the zone performing
@@ -126,15 +136,5 @@ module Spree
       def remove_previous_default
         Spree::Zone.where('id != ?', self.id).update_all(default_tax: false) if default_tax
       end
-
-      def set_zone_members(ids, type)
-        zone_members.destroy_all
-        ids.reject{ |id| id.blank? }.map do |id|
-          member = ZoneMember.new
-          member.zoneable_type = type
-          member.zoneable_id = id
-          members << member
-        end
-      end
   end
 end