spree_core 2.1.12 → 2.2.0

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

@@ -10,7 +10,7 @@ module Spree
           quantity = line_item.quantity
         end
 
-        quantifier = Stock::Quantifier.new(line_item.variant)
+        quantifier = Stock::Quantifier.new(line_item.variant_id)
 
         unless quantifier.can_supply? quantity
           variant = line_item.variant

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

@@ -29,7 +29,19 @@ module Spree
       def calculate_shipping_rates(package)
         shipping_methods(package).map do |shipping_method|
           cost = shipping_method.calculator.compute(package)
-          shipping_method.shipping_rates.new(cost: cost) if cost
+          tax_category = shipping_method.tax_category
+          if tax_category
+            tax_rate = tax_category.tax_rates.detect do |rate|
+              rate.zone == package.order.tax_zone
+            end
+          end
+
+          if cost
+            rate = shipping_method.shipping_rates.new(cost: cost)
+            rate.tax_rate = tax_rate if tax_rate
+          end
+
+          rate
         end.compact
       end
 

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

@@ -1,7 +1,7 @@
 module Spree
   module Stock
     class Package
-      ContentItem = Struct.new(:variant, :quantity, :state)
+      ContentItem = Struct.new(:line_item, :variant, :quantity, :state)
 
       attr_reader :stock_location, :order, :contents
       attr_accessor :shipping_rates
@@ -13,8 +13,8 @@ module Spree
         @shipping_rates = Array.new
       end
 
-      def add(variant, quantity, state=:on_hand)
-        contents << ContentItem.new(variant, quantity, state)
+      def add(line_item, quantity, state = :on_hand, variant = nil)
+        contents << ContentItem.new(line_item, variant || line_item.variant, quantity, state)
       end
 
       def weight
@@ -29,10 +29,13 @@ module Spree
         contents.select { |item| item.state == :backordered }
       end
 
-      def find_item(variant, state=:on_hand)
+      # Consider extensions and applications might create a inventory unit
+      # where the variant and the line_item might not refer to the same product
+      def find_item(variant, state = :on_hand, line_item = nil)
         contents.select do |item|
           item.variant == variant &&
-          item.state == state
+          item.state == state &&
+          (line_item.nil? || line_item == item.line_item)
         end.first
       end
 
@@ -55,7 +58,7 @@ module Spree
         flat = []
         contents.each do |item|
           item.quantity.times do
-            flat << ContentItem.new(item.variant, 1, item.state)
+            flat << ContentItem.new(item.line_item, item.variant, 1, item.state)
           end
         end
         flat
@@ -68,7 +71,7 @@ module Spree
           if current_item
             current_item.quantity += 1
           else
-            add(item.variant, item.quantity, item.state)
+            add(item.line_item, item.quantity, item.state)
           end
         end
       end
@@ -105,6 +108,7 @@ module Spree
             unit.pending = true
             unit.order = order
             unit.variant = item.variant
+            unit.line_item = item.line_item
             unit.state = item.state.to_s
           end
         end

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

@@ -24,10 +24,10 @@ module Spree
             next unless stock_location.stock_item(line_item.variant)
 
             on_hand, backordered = stock_location.fill_status(line_item.variant, line_item.quantity)
-            package.add line_item.variant, on_hand, :on_hand if on_hand > 0
-            package.add line_item.variant, backordered, :backordered if backordered > 0
+            package.add line_item, on_hand, :on_hand if on_hand > 0
+            package.add line_item, backordered, :backordered if backordered > 0
           else
-            package.add line_item.variant, line_item.quantity, :on_hand
+            package.add line_item, line_item.quantity, :on_hand
           end
         end
         package

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

@@ -4,7 +4,7 @@ module Spree
       attr_reader :stock_items
 
       def initialize(variant)
-        @variant = variant
+        @variant = resolve_variant_id(variant)
         @stock_items = Spree::StockItem.joins(:stock_location).where(:variant_id => @variant, Spree::StockLocation.table_name =>{ :active => true})
       end
 
@@ -24,6 +24,14 @@ module Spree
         total_on_hand >= required || backorderable?
       end
 
+      private
+
+      # return variant when passed either variant object or variant id
+      def resolve_variant_id(variant)
+        variant = Spree::Variant.find_by_id(variant) unless variant.respond_to?(:should_track_inventory?)
+        variant
+      end
+
     end
   end
 end

data/app/models/spree/stock_item.rb

@@ -3,14 +3,17 @@ module Spree
     acts_as_paranoid
 
     belongs_to :stock_location, class_name: 'Spree::StockLocation'
-    belongs_to :variant, class_name: 'Spree::Variant', touch: true
-    has_many :stock_movements
+    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]
 
     delegate :weight, :should_track_inventory?, to: :variant
 
+    after_save :conditional_variant_touch
+    after_touch { variant.touch }
+
     def backordered_inventory_units
       Spree::InventoryUnit.backordered_for_stock_item(self)
     end
@@ -44,10 +47,6 @@ module Spree
       self.in_stock? || self.backorderable?
     end
 
-    def variant
-      Spree::Variant.unscoped { super }
-    end
-
     private
       def count_on_hand=(value)
         write_attribute(:count_on_hand, value)
@@ -63,5 +62,11 @@ module Spree
           end
         end
       end
+
+      def conditional_variant_touch
+        if !Spree::Config.binary_inventory_cache || (count_on_hand_changed? && count_on_hand_change.any?(&:zero?))
+          variant.touch
+        end
+      end
   end
 end

data/app/models/spree/stock_movement.rb

@@ -1,9 +1,8 @@
 module Spree
   class StockMovement < ActiveRecord::Base
-    belongs_to :stock_item, class_name: 'Spree::StockItem'
+    belongs_to :stock_item, class_name: 'Spree::StockItem', inverse_of: :stock_movements
     belongs_to :originator, polymorphic: true
 
-
     after_create :update_stock_item_quantity
 
     validates :stock_item, presence: true

data/app/models/spree/tax_category.rb

@@ -11,7 +11,12 @@ module Spree
       #set existing default tax category to false if this one has been marked as default
 
       if is_default && tax_category = self.class.where(is_default: true).first
-        tax_category.update_column(:is_default, false) unless tax_category == self
+        unless tax_category == self
+          tax_category.update_columns(
+            is_default: false,
+            updated_at: Time.now,
+          )
+        end
       end
     end
   end

data/app/models/spree/tax_rate.rb

@@ -15,6 +15,8 @@ module Spree
     belongs_to :zone, class_name: "Spree::Zone"
     belongs_to :tax_category, class_name: "Spree::TaxCategory"
 
+    has_many :adjustments, as: :source, dependent: :destroy
+
     validates :amount, presence: true, numericality: true
     validates :tax_category_id, presence: true
     validates_with DefaultTaxZoneValidator
@@ -23,20 +25,40 @@ module Spree
 
     # Gets the array of TaxRates appropriate for the specified order
     def self.match(order)
-      order_zone = order.tax_zone
-      return [] unless order_zone
-      includes(zone: { zone_members: :zoneable }).load.select do |rate|
+      return [] unless order.tax_zone
+      all.select do |rate|
         (!rate.included_in_price && (rate.zone == order.tax_zone || rate.zone.contains?(order.tax_zone) || (order.tax_address.nil? && rate.zone.default_tax))) ||
         rate.included_in_price
       end
     end
 
-    def self.adjust(order)
-      order.adjustments.tax.destroy_all
-      order.line_item_adjustments.where(originator_type: 'Spree::TaxRate').destroy_all
+    # Pre-tax amounts must be stored so that we can calculate 
+    # 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
+        end
+        pre_tax_amount = item_amount / (1 + rates.map(&:amount).sum)
+        item.update_column(:pre_tax_amount, pre_tax_amount)
+      end
+    end
 
-      self.match(order).each do |rate|
-        rate.adjust(order)
+    def self.adjust(order, items)
+      rates = self.match(order)
+      tax_categories = rates.map(&:tax_category)
+      relevant_items = items.select { |item| tax_categories.include?(item.tax_category) }
+      relevant_items.each do |item|
+        item.adjustments.tax.delete_all
+        relevant_rates = rates.select { |rate| rate.tax_category == item.tax_category }
+        store_pre_tax_amount(item, relevant_rates)
+        relevant_rates.each do |rate|
+          rate.adjust(order, item)
+        end
       end
     end
 
@@ -54,51 +76,37 @@ module Spree
     end
 
     # Creates necessary tax adjustments for the order.
-    def adjust(order)
-      # (rate.included_in_price && !order.tax_address.nil? && !rate.zone.contains?(order.tax_zone) && rate.zone.default_tax)
-      label = create_label
+    def adjust(order, item)
+      amount = calculator.compute(item)
+      return if amount == 0
+
+      included = included_in_price &&
+                 Zone.default_tax.contains?(item.order.tax_zone)
+
+      if amount < 0
+        label = Spree.t(:refund) + ' ' + create_label
+      end
+
+      self.adjustments.create!({
+        :adjustable => item,
+        :amount => amount,
+        :order => order,
+        :label => label || create_label,
+        :included => included
+      })
+    end
+
+    # This method is used by Adjustment#update to recalculate the cost.
+    def compute_amount(item)
       if included_in_price
-        if Zone.default_tax.contains? order.tax_zone
-          order.line_items.each do |line_item|
-            amount = calculator.compute(line_item)
-            unless amount == 0
-              line_item.adjustments.create(
-                order: order,
-                amount: amount,
-                source: line_item,
-                originator: self,
-                label: label,
-                mandatory: false,
-                state: "closed",
-                included: true
-              )
-            end
-          end
+        if Zone.default_tax.contains? item.order.tax_zone
+          calculator.compute(item)
         else
-          amount = -1 * calculator.compute(order)
-          label = Spree.t(:refund) + label
-
-          order.adjustments.create(
-            order: order,
-            amount: amount,
-            source: order,
-            originator: self,
-            state: "closed",
-            label: label
-          )
+          # In this case, it's a refund.
+          calculator.compute(item) * - 1
         end
       else
-        amount = calculator.compute(order)
-        unless amount == 0
-          order.adjustments.create(
-            order: order,
-            amount: amount,
-            source: order,
-            originator: self,
-            state: "closed",
-            label: label
-          )
-        end
+        calculator.compute(item)
       end
     end
 

data/app/models/spree/taxon.rb

@@ -2,14 +2,16 @@ module Spree
   class Taxon < ActiveRecord::Base
     acts_as_nested_set dependent: :destroy
 
-    belongs_to :taxonomy, class_name: 'Spree::Taxonomy', :touch => true
-    has_many :classifications, dependent: :delete_all
+    belongs_to :taxonomy, class_name: 'Spree::Taxonomy', touch: true, inverse_of: :taxons
+    has_many :classifications, -> { order(:position) }, dependent: :delete_all, inverse_of: :taxon
     has_many :products, through: :classifications
 
     before_create :set_permalink
 
     validates :name, presence: true
 
+    after_touch :touch_parent
+
     has_attached_file :icon,
       styles: { mini: '32x32>', normal: '128x128>' },
       default_style: :mini,
@@ -17,9 +19,6 @@ module Spree
       path: ':rails_root/public/spree/taxons/:id/:style/:basename.:extension',
       default_url: '/assets/default_taxon.png'
 
-    include Spree::Core::S3Support
-    supports_s3 :icon
-
     include Spree::Core::ProductFilters  # for detailed defs of filters
 
     # indicate which filters should be used for a taxon
@@ -78,5 +77,11 @@ module Spree
     def child_index=(idx)
       move_to_child_with_index(parent, idx.to_i) unless self.new_record?
     end
+
+    private
+
+    def touch_parent
+      parent.touch if parent
+    end
   end
 end

data/app/models/spree/taxonomy.rb

@@ -2,7 +2,7 @@ module Spree
   class Taxonomy < ActiveRecord::Base
     validates :name, presence: true
 
-    has_many :taxons
+    has_many :taxons, inverse_of: :taxonomy
     has_one :root, -> { where parent_id: nil }, class_name: "Spree::Taxon", dependent: :destroy
 
     after_save :set_name
@@ -12,7 +12,10 @@ module Spree
     private
       def set_name
         if root
-          root.update_column(:name, name)
+          root.update_columns(
+            name: name,
+            updated_at: Time.now,
+          )
         else
           self.root = Taxon.create!(taxonomy_id: id, name: name)
         end

data/app/models/spree/variant.rb

@@ -2,20 +2,21 @@ module Spree
   class Variant < ActiveRecord::Base
     acts_as_paranoid
 
-    belongs_to :product, touch: true, class_name: 'Spree::Product'
+    belongs_to :product, touch: true, class_name: 'Spree::Product', inverse_of: :variants
+    belongs_to :tax_category, class_name: 'Spree::TaxCategory'
 
-    delegate_belongs_to :product, :name, :description, :permalink, :available_on,
-                        :tax_category_id, :shipping_category_id, :meta_description,
-                        :meta_keywords, :tax_category, :shipping_category
+    delegate_belongs_to :product, :name, :description, :slug, :available_on,
+                        :shipping_category_id, :meta_description, :meta_keywords,
+                        :shipping_category
 
     has_many :inventory_units
-    has_many :line_items
+    has_many :line_items, inverse_of: :variant
 
-    has_many :stock_items, dependent: :destroy
+    has_many :stock_items, dependent: :destroy, inverse_of: :variant
     has_many :stock_locations, through: :stock_items
     has_many :stock_movements
 
-    has_and_belongs_to_many :option_values, join_table: :spree_option_values_variants, class_name: "Spree::OptionValue"
+    has_and_belongs_to_many :option_values, join_table: :spree_option_values_variants
     has_many :images, -> { order(:position) }, as: :viewable, dependent: :destroy, class_name: "Spree::Image"
 
     has_one :default_price,
@@ -27,7 +28,8 @@ module Spree
 
     has_many :prices,
       class_name: 'Spree::Price',
-      dependent: :destroy
+      dependent: :destroy,
+      inverse_of: :variant
 
     validate :check_price
     validates :price, numericality: { greater_than_or_equal_to: 0 }
@@ -39,6 +41,8 @@ module Spree
     after_create :create_stock_items
     after_create :set_position
 
+    after_touch :clear_in_stock_cache
+
     # default variant scope only lists non-deleted variants
     scope :deleted, lambda { where.not(deleted_at: nil) }
 
@@ -46,6 +50,14 @@ module Spree
       joins(:prices).where(deleted_at: nil).where('spree_prices.currency' => currency || Spree::Config[:currency]).where('spree_prices.amount IS NOT NULL')
     end
 
+    def tax_category
+      if self[:tax_category_id].nil?
+        product.tax_category
+      else
+        TaxCategory.find(self[:tax_category_id])
+      end
+    end
+
     def cost_price=(price)
       self[:cost_price] = parse_price(price) if price.present?
     end
@@ -75,7 +87,7 @@ module Spree
     # allows extensions to override deleted? if they want to provide
     # their own definition.
     def deleted?
-      !!deleted_at
+      deleted_at
     end
 
     # Product may be created with deleted_at already set,
@@ -149,16 +161,13 @@ module Spree
       "#{sku} #{options_text}".strip
     end
 
-    def in_stock?(quantity=:argument_here_is_deprecated)
-      if quantity == :argument_here_is_deprecated
-        can_stock?(1)
-      else
-        puts %q{[DEPRECATION] In Spree 2.2, Variant#in_stock? will no longer take a quantity. Use Variant#can_supply? instead.}
-        can_stock?(quantity)
+    def in_stock?
+      Rails.cache.fetch(in_stock_cache_key) do
+        total_on_hand > 0
       end
     end
 
-    def can_stock?(quantity=1)
+    def can_supply?(quantity=1)
       Spree::Stock::Quantifier.new(self).can_supply?(quantity)
     end
 
@@ -214,6 +223,14 @@ module Spree
       def set_position
         self.update_column(:position, product.variants.maximum(:position).to_i + 1)
       end
+
+      def in_stock_cache_key
+        "variant-#{id}-in_stock"
+      end
+
+      def clear_in_stock_cache
+        Rails.cache.delete(in_stock_cache_key)
+      end
   end
 end