spree_core 2.1.12 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 413409a6e11793b4c41aac79f57541c2b4b6c8b4
-  data.tar.gz: 61e14410d4987119dd34a5694b97acefb0578cb3
+  metadata.gz: bec161c547d1c0a301e068937cff9a461ff7a6cc
+  data.tar.gz: 5ea11fca1a903043e7776db55c5092a676a31c40
 SHA512:
-  metadata.gz: 2c6a19efdbfd4a44dde5cf6a42532c2c59e95fe94e6700aaf6816b47312a46ee1987376cb13646701ba0c8b0195c842abf8cc129e40cb23faf63b71372a52294
-  data.tar.gz: a69ffad30b460d6e910f825c0b60e346030a0c120d361bdbebd27ff324eb9783e34d243cca4d7a8ac4c80aca0ed031bfc5639f3a08fd608529e4ad6752f6b0cd
+  metadata.gz: 1f618e1c470a7a552a2b6b97d72b2702c52d8beba2298d6ab6400982f024a466bc9b857af1e3b447ca5ab8c079d8d44bac78877516baa1a8962ef7f9eac0b244
+  data.tar.gz: 3be703d2a9d163edb81d227463859a7cb5a181091539780f5b0eb4173ad2f69cf8ff74e824361d312e6571ffbbedef6c8f12eb06fb6649cd2902771f5f537754

data/app/helpers/spree/base_helper.rb

@@ -13,16 +13,14 @@ module Spree
     end
 
     def link_to_cart(text = nil)
-      return "" if current_spree_page?(spree.cart_path)
-
       text = text ? h(text) : Spree.t('cart')
       css_class = nil
 
-      if current_order.nil? or current_order.item_count.zero?
+      if simple_current_order.nil? or simple_current_order.item_count.zero?
         text = "#{text}: (#{Spree.t('empty')})"
         css_class = 'empty'
       else
-        text = "#{text}: (#{current_order.item_count})  <span class='amount'>#{current_order.display_total.to_html}</span>".html_safe
+        text = "#{text}: (#{simple_current_order.item_count})  <span class='amount'>#{simple_current_order.display_total.to_html}</span>".html_safe
         css_class = 'full'
       end
 
@@ -120,7 +118,7 @@ module Spree
       countries.collect do |country|
         country.name = Spree.t(country.iso, scope: 'country_names', default: country.name)
         country
-      end.sort_by { |c| c.name.parameterize }
+      end.sort { |a, b| a.name.parameterize <=> b.name.parameterize }
     end
 
     def seo_url(taxon)
@@ -164,10 +162,9 @@ module Spree
     end
 
     private
-
     # Returns style of image or nil
     def image_style_from_method_name(method_name)
-      if method_name.to_s.match(/_image$/) && style = method_name.to_s.sub(/_image$/, '')
+      if style = method_name.to_s.sub(/_image$/, '')
         possible_styles = Spree::Image.attachment_definitions[:attachment][:styles]
         style if style.in? possible_styles.with_indifferent_access
       end

data/app/helpers/spree/products_helper.rb

@@ -12,13 +12,14 @@ module Spree
 
     # returns the formatted price for the specified variant as a difference from product price
     def variant_price_diff(variant)
-      variant_amount = variant.amount_in(current_currency)
-      product_amount = variant.product.amount_in(current_currency)
-      return if variant_amount == product_amount || product_amount.nil?
-      diff   = variant.amount_in(current_currency) - product_amount
-      amount = Spree::Money.new(diff.abs, currency: current_currency).to_html
-      label  = diff > 0 ? :add : :subtract
-      "(#{Spree.t(label)}: #{amount})".html_safe
+      diff = variant.amount_in(current_currency) - variant.product.amount_in(current_currency)
+      return nil if diff == 0
+      amount = Spree::Money.new(diff.abs, { currency: current_currency }).to_html
+      if diff > 0
+        "(#{Spree.t(:add)}: #{amount})".html_safe
+      else
+        "(#{Spree.t(:subtract)}: #{amount})".html_safe
+      end
     end
 
     # returns the formatted full price for the variant, if at least one variant price differs from product price
@@ -52,8 +53,9 @@ module Spree
       end
     end
 
-    def get_taxonomies
-      @taxonomies ||= Spree::Taxonomy.includes(root: :children)
+    def cache_key_for_products
+      max_updated_at = @products.maximum(:updated_at).to_s(:number)
+      "#{current_currency}/spree/products/all-#{params[:page]}-#{max_updated_at}"
     end
   end
 end

data/app/helpers/spree/store_helper.rb

@@ -7,5 +7,10 @@ module Spree
       %w{thank_you}.exclude? params[:action]
     end
 
+    def cache_key_for_taxons
+      max_updated_at = @taxons.maximum(:updated_at).to_i
+      parts = [@taxon.try(:id), max_updated_at].compact.join("-")
+      "taxons/#{parts}"
+    end
   end
 end

data/app/models/spree/ability.rb

@@ -47,6 +47,10 @@ module Spree
         can :update, Order do |order, token|
           order.user == user || order.token && token == order.token
         end
+        can [:create, :read], Address
+        can :update, Address do |address|
+          user.bill_address == address || user.ship_address == address
+        end
         can [:index, :read], Product
         can [:index, :read], ProductProperty
         can [:index, :read], Property

data/app/models/spree/address.rb

@@ -3,7 +3,7 @@ module Spree
     belongs_to :country, class_name: "Spree::Country"
     belongs_to :state, class_name: "Spree::State"
 
-    has_many :shipments
+    has_many :shipments, inverse_of: :address
 
     validates :firstname, :lastname, :address1, :city, :country, presence: true
     validates :zipcode, presence: true, if: :require_zipcode?
@@ -19,11 +19,6 @@ module Spree
       new(country: country)
     end
 
-    # Can modify an address if it's not been used in an order (but checkouts controller has finer control)
-    # def editable?
-    #   new_record? || (shipments.empty? && checkouts.empty?)
-    # end
-
     def self.default(user = nil, kind = "bill")
       if user
         user.send(:"#{kind}_address") || build_default
@@ -32,6 +27,11 @@ module Spree
       end
     end
 
+    # Can modify an address if it's not been used in an order (but checkouts controller has finer control)
+    # def editable?
+    #   new_record? || (shipments.empty? && checkouts.empty?)
+    # end
+
     def full_name
       "#{firstname} #{lastname}".strip
     end

data/app/models/spree/adjustment.rb

@@ -1,10 +1,8 @@
 # Adjustments represent a change to the +item_total+ of an Order. Each adjustment
 # has an +amount+ that can be either positive or negative.
 #
-# Adjustments can be open/closed/finalized
-#
-# Once an adjustment is finalized, it cannot be changed, but an adjustment can
-# toggle between open/closed as needed
+# Adjustments can be "opened" or "closed".
+# Once an adjustment is closed, it will not be automatically updated.
 #
 # Boolean attributes:
 #
@@ -26,83 +24,67 @@ module Spree
   class Adjustment < ActiveRecord::Base
     belongs_to :adjustable, polymorphic: true
     belongs_to :source, polymorphic: true
-    belongs_to :originator, polymorphic: true
-    belongs_to :order, :class_name => 'Spree::Order'
+    belongs_to :order, :class_name => "Spree::Order"
 
     validates :label, presence: true
     validates :amount, numericality: true
 
-    after_save :update_adjustable
-    after_destroy :update_adjustable
-
     state_machine :state, initial: :open do
       event :close do
         transition from: :open, to: :closed
       end
 
-      event :open do
-        transition from: :closed, to: :open
-      end
-
-      event :finalize do
-        transition from: [:open, :closed], to: :finalized
+      event :close do
+        transition from: :close, to: :open
       end
     end
 
-    scope :tax, -> { where(originator_type: 'Spree::TaxRate') }
+    after_create :update_adjustable_adjustment_total
+
+    scope :open, -> { where(state: 'open') }
+    scope :tax, -> { where(source_type: 'Spree::TaxRate') }
     scope :price, -> { where(adjustable_type: 'Spree::LineItem') }
-    scope :shipping, -> { where(originator_type: 'Spree::ShippingMethod') }
+    scope :shipping, -> { where(adjustable_type: 'Spree::Shipment') }
     scope :optional, -> { where(mandatory: false) }
     scope :eligible, -> { where(eligible: true) }
     scope :charge, -> { where("#{quoted_table_name}.amount >= 0") }
     scope :credit, -> { where("#{quoted_table_name}.amount < 0") }
-    scope :promotion, -> { where(originator_type: 'Spree::PromotionAction') }
-    scope :manual, -> { where(originator_type: nil) }
+    scope :promotion, -> { where(source_type: 'Spree::PromotionAction') }
     scope :return_authorization, -> { where(source_type: "Spree::ReturnAuthorization") }
     scope :included, -> { where(included: true)  }
     scope :additional, -> { where(included: false) }
 
-    def promotion?
-      originator_type == 'Spree::PromotionAction'
-    end
-
-    # Update the boolean _eligible_ attribute which determines which adjustments
-    # count towards the order's adjustment_total.
-    def set_eligibility
-      result = mandatory || ((amount != 0 || promotion?) && eligible_for_originator?)
-      update_column(:eligible, result)
+    def closed?
+      state == "closed"
     end
 
-    # Allow originator of the adjustment to perform an additional eligibility of the adjustment
-    # Should return _true_ if originator is absent or doesn't implement _eligible?_
-    def eligible_for_originator?
-      return true if originator.nil?
-      !originator.respond_to?(:eligible?) || originator.eligible?(source)
+    def promotion?
+      source.class < Spree::PromotionAction
     end
 
-    # Update both the eligibility and amount of the adjustment. Adjustments
-    # delegate updating of amount to their Originator when present, but only if
-    # +locked+ is false. Adjustments that are +locked+ will never change their amount.
+    # Recalculate amount given a target e.g. Order, Shipment, LineItem
     #
-    # Adjustments delegate updating of amount to their Originator when present,
-    # but only if when they're in "open" state, closed or finalized adjustments
-    # are not recalculated.
+    # Passing a target here would always be recommended as it would avoid
+    # hitting the database again and would ensure you're compute values over
+    # the specific object amount passed here.
     #
-    # It receives +calculable+ as the updated source here so calculations can be
-    # performed on the current values of that source. If we used +source+ it
-    # could load the old record from db for the association. e.g. when updating
-    # more than on line items at once via accepted_nested_attributes the order
-    # object on the association would be in a old state and therefore the
-    # adjustment calculations would not performed on proper values
-    def update!(calculable = nil)
-      return if immutable?
-      # Fix for #3381
-      # If we attempt to call 'source' before the reload, then source is currently
-      # the order object. After calling a reload, the source is the Shipment.
-      reload
-      calculable = source unless calculable == source
-      originator.update_adjustment(self, calculable) if originator.present?
-      set_eligibility
+    # Noop if the adjustment is locked.
+    #
+    # If the adjustment has no source, do not attempt to re-calculate the amount.
+    # Chances are likely that this was a manually created adjustment in the admin backend.
+    def update!(target = nil)
+      return amount if closed?
+      if source.present?
+        amount = source.compute_amount(target || adjustable)
+        self.update_columns(
+          amount: amount,
+          updated_at: Time.now,
+        )
+        if promotion?
+          self.update_column(:eligible, source.promotion.eligible?(adjustable))
+        end
+      end
+      amount
     end
 
     def currency
@@ -113,14 +95,11 @@ module Spree
       Spree::Money.new(amount, { currency: currency })
     end
 
-    def immutable?
-      state != "open"
-    end
-
     private
 
-      def update_adjustable
-        adjustable.update! if adjustable.is_a? Order
-      end
+    def update_adjustable_adjustment_total
+      # Cause adjustable's total to be recalculated
+      Spree::ItemAdjustments.new(adjustable).update if adjustable
+    end
   end
 end

data/app/models/spree/app_configuration.rb

@@ -35,6 +35,7 @@ module Spree
     preference :always_include_confirm_step, :boolean, default: false # Ensures confirmation step is always in checkout_progress bar, but does not force a confirm step if your payment methods do not support it.
     preference :always_put_site_name_in_title, :boolean, default: true
     preference :auto_capture, :boolean, default: false # automatically capture the credit card (as opposed to just authorize and capture later)
+    preference :binary_inventory_cache, :boolean, default: false # only invalidate product cache when a stock item changes whether it is in_stock
     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
     preference :company, :boolean, default: false # Request company field for billing and shipping addr
@@ -70,20 +71,6 @@ module Spree
     preference :tax_using_ship_address, :boolean, default: true
     preference :track_inventory_levels, :boolean, default: true # Determines whether to track on_hand values for variants / products.
 
-    # Preferences related to image settings
-    preference :attachment_default_url, :string, default: '/spree/products/:id/:style/:basename.:extension'
-    preference :attachment_path, :string, default: ':rails_root/public/spree/products/:id/:style/:basename.:extension'
-    preference :attachment_url, :string, default: '/spree/products/:id/:style/:basename.:extension'
-    preference :attachment_styles, :string, default: "{\"mini\":\"48x48>\",\"small\":\"100x100>\",\"product\":\"240x240>\",\"large\":\"600x600>\"}"
-    preference :attachment_default_style, :string, default: 'product'
-    preference :s3_access_key, :string
-    preference :s3_bucket, :string
-    preference :s3_secret, :string
-    preference :s3_headers, :string, default: "{\"Cache-Control\":\"max-age=31557600\"}"
-    preference :use_s3, :boolean, default: false # Use S3 for images rather than the file system
-    preference :s3_protocol, :string
-    preference :s3_host_alias, :string
-
     # Default mail headers settings
     preference :enable_mail_delivery, :boolean, :default => false
     preference :send_core_emails, :boolean, :default => true

data/app/models/spree/calculator.rb

@@ -2,11 +2,19 @@ module Spree
   class Calculator < ActiveRecord::Base
     belongs_to :calculable, polymorphic: true
 
-    # This method must be overriden in concrete calculator.
+    # This method calls a compute_<computable> method. must be overriden in concrete calculator.
     #
-    # It should return amount computed based on #calculable and/or optional parameter
-    def compute(something = nil)
-      raise NotImplementedError, 'please use concrete calculator'
+    # It should return amount computed based on #calculable and the computable parameter
+    def compute(computable)
+      # Spree::LineItem -> :compute_line_item
+      computable_name = computable.class.name.demodulize.underscore
+      method = "compute_#{computable_name}".to_sym
+      calculator_class = self.class
+      begin
+        self.send(method, computable)
+      rescue NoMethodError
+        raise NotImplementedError, "Please implement '#{method}(#{computable_name})' in your calculator: #{calculator_class.name}"
+      end
     end
 
     # overwrite to provide description for your calculators

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

@@ -6,54 +6,58 @@ module Spree
       Spree.t(:default_tax)
     end
 
-    def compute(computable)
-      case computable
-        when Spree::Order
-          compute_order(computable)
-        when Spree::LineItem
-          compute_line_item(computable)
+    # Default tax calculator still needs to support orders for legacy reasons
+    # Orders created before Spree 2.1 had tax adjustments applied to the order, as a whole.
+    # Orders created with Spree 2.2 and after, have them applied to the line items individually.
+    def compute_order(order)
+
+      matched_line_items = order.line_items.select do |line_item|
+        line_item.tax_category == rate.tax_category
+      end
+
+      line_items_total = matched_line_items.sum(&:total)
+      if rate.included_in_price
+        round_to_two_places(line_items_total - ( line_items_total / (1 + rate.amount) ) )
+      else
+        round_to_two_places(line_items_total * rate.amount)
       end
     end
 
+    # When it comes to computing shipments or line items: same same.
+    def compute_shipment_or_line_item(item)
+      if rate.included_in_price
+        deduced_total_by_rate(item.pre_tax_amount, rate)
+      else
+        round_to_two_places(item.discounted_amount * rate.amount)
+      end
+    end
 
-    private
+    alias_method :compute_shipment, :compute_shipment_or_line_item
+    alias_method :compute_line_item, :compute_shipment_or_line_item
 
-      def rate
-        self.calculable
+    def compute_shipping_rate(shipping_rate)
+      if rate.included_in_price
+        pre_tax_amount = shipping_rate.cost / (1 + rate.amount)
+        deduced_total_by_rate(pre_tax_amount, rate)
+      else
+        with_tax_amount = shipping_rate.cost * rate.amount
+        round_to_two_places(with_tax_amount)
       end
+    end
 
-      def compute_order(order)
-        matched_line_items = order.line_items.select do |line_item|
-          line_item.tax_category == rate.tax_category
-        end
-
-        line_items_total = matched_line_items.sum(&:total)
-        if rate.included_in_price
-          deduced_total_by_rate(line_items_total, rate)
-        else
-          round_to_two_places(line_items_total * rate.amount)
-        end
-      end
+    private
 
-      def compute_line_item(line_item)
-        if line_item.tax_category == rate.tax_category
-          if rate.included_in_price
-            deduced_total_by_rate(line_item.total, rate)
-          else
-            round_to_two_places(line_item.total * rate.amount)
-          end
-        else
-          0
-        end
-      end
+    def rate
+      self.calculable
+    end
 
-      def round_to_two_places(amount)
-        BigDecimal.new(amount.to_s).round(2, BigDecimal::ROUND_HALF_UP)
-      end
+    def round_to_two_places(amount)
+      BigDecimal.new(amount.to_s).round(2, BigDecimal::ROUND_HALF_UP)
+    end
 
-      def deduced_total_by_rate(total, rate)
-        round_to_two_places(total - ( total / (1 + rate.amount) ) )
-      end
+    def deduced_total_by_rate(pre_tax_amount, rate)
+      round_to_two_places(pre_tax_amount * rate.amount)
+    end
 
   end
 end

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

@@ -8,10 +8,8 @@ module Spree
       Spree.t(:flat_percent)
     end
 
-    def compute(object)
-      return unless object.present? and object.respond_to?(:item_total)
-      item_total = object.item_total
-      value = item_total * BigDecimal(self.preferred_flat_percent.to_s) / 100.0
+    def compute(line_item)
+      value = line_item.amount * BigDecimal(self.preferred_flat_percent.to_s) / 100.0
       (value * 100).round.to_f / 100
     end
   end