solidus_core 1.2.3 → 1.3.0.beta1

data/app/models/concerns/spree/user_address_book.rb

@@ -3,8 +3,7 @@ module Spree
     extend ActiveSupport::Concern
 
     included do
-      has_many :user_addresses, -> { active }, {foreign_key: "user_id", class_name: "Spree::UserAddress"} do
-
+      has_many :user_addresses, -> { active }, { foreign_key: "user_id", class_name: "Spree::UserAddress" } do
         def find_first_by_address_values(address_attrs)
           detect { |ua| ua.address == Address.new(address_attrs) }
         end
@@ -13,7 +12,7 @@ module Spree
         def mark_default(user_address)
           # the checks of persisted? allow us to build a User and associate Addresses at once
           ActiveRecord::Base.transaction do
-            (self - [user_address]).each do |ua| #update_all would be nice, but it bypasses ActiveRecord callbacks
+            (self - [user_address]).each do |ua| # update_all would be nice, but it bypasses ActiveRecord callbacks
               ua.persisted? ? ua.update!(default: false) : ua.default = false
             end
             user_address.persisted? ? user_address.update!(default: true, archived: false) : user_address.default = true
@@ -26,109 +25,116 @@ module Spree
       # bill_address is only minimally used now, but we can't get rid of it without a major version release
       belongs_to :bill_address, class_name: 'Spree::Address'
 
-      def bill_address=(address)
-        # stow a copy in our address book too
-        address = save_in_address_book(address.attributes) if address
-        super(address)
-      end
+      has_one :default_user_address, ->{ default }, class_name: 'Spree::UserAddress', foreign_key: 'user_id'
+      has_one :default_address, through: :default_user_address, source: :address
+      alias_method :ship_address, :default_address
+    end
 
-      def bill_address_attributes=(attributes)
-        self.bill_address = Address.immutable_merge(bill_address, attributes)
-      end
+    def bill_address=(address)
+      # stow a copy in our address book too
+      address = save_in_address_book(address.attributes) if address
+      super(address)
+    end
 
-      def default_address
-        user_addresses.default.first.try(:address)
-      end
+    def bill_address_attributes=(attributes)
+      self.bill_address = Address.immutable_merge(bill_address, attributes)
+    end
 
-      def default_address=(address)
-        save_in_address_book(address.attributes, true) if address
-      end
+    def default_address=(address)
+      save_in_address_book(address.attributes, true) if address
+    end
 
-      def default_address_attributes=(attributes)
-        # see "Nested Attributes Examples" section of http://apidock.com/rails/ActionView/Helpers/FormHelper/fields_for
-        # this #{fieldname}_attributes= method works with fields_for in the views
-        # even without declaring accepts_nested_attributes_for
-        self.default_address = Address.immutable_merge(default_address, attributes)
-      end
+    def default_address_attributes=(attributes)
+      # see "Nested Attributes Examples" section of http://apidock.com/rails/ActionView/Helpers/FormHelper/fields_for
+      # this #{fieldname}_attributes= method works with fields_for in the views
+      # even without declaring accepts_nested_attributes_for
+      self.default_address = Address.immutable_merge(default_address, attributes)
+    end
 
-      alias_method :ship_address, :default_address
-      alias_method :ship_address_attributes=, :default_address_attributes=
-
-      # saves address in address book
-      # sets address to the default if automatic_default_address is set to true
-      # if address is nil, does nothing and returns nil
-      def ship_address=(address)
-        be_default = Spree::Config.automatic_default_address
-        save_in_address_book(address.attributes, be_default) if address
-      end
+    alias_method :ship_address_attributes=, :default_address_attributes=
 
-      # saves order.ship_address and order.bill_address in address book
-      # sets ship_address to the default if automatic_default_address is set to true
-      # sets bill_address to the default if automatic_default_address is set to true and there is no ship_address
-      # if one address is nil, does not save that address
-      def persist_order_address(order)
-        save_in_address_book(
+    # saves address in address book
+    # sets address to the default if automatic_default_address is set to true
+    # if address is nil, does nothing and returns nil
+    def ship_address=(address)
+      be_default = Spree::Config.automatic_default_address
+      save_in_address_book(address.attributes, be_default) if address
+    end
+
+    # saves order.ship_address and order.bill_address in address book
+    # sets ship_address to the default if automatic_default_address is set to true
+    # sets bill_address to the default if automatic_default_address is set to true and there is no ship_address
+    # if one address is nil, does not save that address
+    def persist_order_address(order)
+      if order.ship_address
+        address = save_in_address_book(
           order.ship_address.attributes,
           Spree::Config.automatic_default_address
-        ) if order.ship_address
+        )
+        self.ship_address_id = address.id if address && address.persisted?
+      end
 
-        save_in_address_book(
+      if order.bill_address
+        address = save_in_address_book(
           order.bill_address.attributes,
           order.ship_address.nil? && Spree::Config.automatic_default_address
-        ) if order.bill_address
+        )
+        self.bill_address_id = address.id if address && address.persisted?
       end
 
-      # Add an address to the user's list of saved addresses for future autofill
-      # @param address_attributes HashWithIndifferentAccess of attributes that will be
-      # treated as value equality to de-dup among existing Addresses
-      # @param default set whether or not this address will show up from
-      # #default_address or not
-      def save_in_address_book(address_attributes, default = false)
-        return nil unless address_attributes.present?
-        address_attributes = address_attributes.with_indifferent_access
+      save! # In case the ship_address_id or bill_address_id was set
+    end
 
-        new_address = Address.factory(address_attributes)
-        return new_address unless new_address.valid?
+    # Add an address to the user's list of saved addresses for future autofill
+    # @param address_attributes HashWithIndifferentAccess of attributes that will be
+    # treated as value equality to de-dup among existing Addresses
+    # @param default set whether or not this address will show up from
+    # #default_address or not
+    def save_in_address_book(address_attributes, default = false)
+      return nil unless address_attributes.present?
+      address_attributes = address_attributes.with_indifferent_access
 
-        first_one = user_addresses.empty?
+      new_address = Address.factory(address_attributes)
+      return new_address unless new_address.valid?
 
-        if address_attributes[:id].present? && new_address.id != address_attributes[:id]
-          remove_from_address_book(address_attributes[:id])
-        end
+      first_one = user_addresses.empty?
 
-        user_address = prepare_user_address(new_address)
-        user_addresses.mark_default(user_address) if (default || first_one)
+      if address_attributes[:id].present? && new_address.id != address_attributes[:id]
+        remove_from_address_book(address_attributes[:id])
+      end
 
-        if persisted?
-          user_address.save!
-          user_addresses.reset #ensures proper ordering
-        end
+      user_address = prepare_user_address(new_address)
+      user_addresses.mark_default(user_address) if default || first_one
 
-        user_address.address
+      if persisted?
+        user_address.save!
+        user_addresses.reset # ensures proper ordering
       end
 
-      def mark_default_address(address)
-        user_addresses.mark_default(user_addresses.find_by(address: address))
-      end
+      user_address.address
+    end
 
-      def remove_from_address_book(address_id)
-        user_address = user_addresses.find_by(address_id: address_id)
-        if user_address
-          user_address.update_attributes(archived: true, default: false)
-        else
-          false
-        end
+    def mark_default_address(address)
+      user_addresses.mark_default(user_addresses.find_by(address: address))
+    end
+
+    def remove_from_address_book(address_id)
+      user_address = user_addresses.find_by(address_id: address_id)
+      if user_address
+        user_address.update_attributes(archived: true, default: false)
+      else
+        false
       end
+    end
 
-      private
+    private
 
-      def prepare_user_address(new_address)
-        user_address = user_addresses.all_historical.find_first_by_address_values(new_address.attributes)
-        user_address ||= user_addresses.build
-        user_address.address = new_address
-        user_address.archived = false
-        user_address
-      end
+    def prepare_user_address(new_address)
+      user_address = user_addresses.all_historical.find_first_by_address_values(new_address.attributes)
+      user_address ||= user_addresses.build
+      user_address.address = new_address
+      user_address.archived = false
+      user_address
     end
   end
 end

data/app/models/concerns/spree/user_methods.rb

@@ -47,7 +47,7 @@ module Spree
     # @return [Spree::Order] the most-recently-created incomplete order
     # since the customer's last complete order.
     def last_incomplete_spree_order(store: nil, only_frontend_viewable: true)
-      self_orders = self.orders
+      self_orders = orders
       self_orders = self_orders.where(frontend_viewable: true) if only_frontend_viewable
       self_orders = self_orders.where(store: store) if store
       self_orders = self_orders.where('updated_at > ?', Spree::Config.completable_order_updated_cutoff_days.days.ago) if Spree::Config.completable_order_updated_cutoff_days
@@ -57,7 +57,7 @@ module Spree
     end
 
     def total_available_store_credit
-      store_credits.reload.to_a.sum{ |credit| credit.amount_remaining }
+      store_credits.reload.to_a.sum(&:amount_remaining)
     end
   end
 end

data/app/models/concerns/spree/user_payment_source.rb

@@ -4,16 +4,20 @@ module Spree
 
     included do
       has_many :credit_cards, class_name: "Spree::CreditCard", foreign_key: :user_id
-      def default_credit_card; credit_cards.default.first; end
+    end
+
+    def default_credit_card
+      credit_cards.default.first
+    end
 
-      def payment_sources
-        credit_cards.with_payment_profile
-      end
+    def payment_sources
+      credit_cards.with_payment_profile
+    end
 
-      def drop_payment_source(source)
-        gateway = source.payment_method
-        gateway.disable_customer_profile(source)
-      end
+    def drop_payment_source(source)
+      ActiveSupport::Deprecation.warn("User#drop_payment_source is deprecated", caller)
+      gateway = source.payment_method
+      gateway.disable_customer_profile(source)
     end
   end
 end

data/app/models/spree/ability.rb

@@ -17,11 +17,11 @@ module Spree
     # the +CanCan::Ability+ module.  The registered ability should behave properly as a stand-alone class
     # and therefore should be easy to test in isolation.
     def self.register_ability(ability)
-      self.abilities.add(ability)
+      abilities.add(ability)
     end
 
     def self.remove_ability(ability)
-      self.abilities.delete(ability)
+      abilities.delete(ability)
     end
 
     def initialize(current_user)

data/app/models/spree/address.rb

@@ -97,7 +97,7 @@ module Spree
     # @return [Boolean] true if the two addresses have the same address fields
     def ==(other_address)
       return false unless other_address && other_address.respond_to?(:value_attributes)
-      self.value_attributes == other_address.value_attributes
+      value_attributes == other_address.value_attributes
     end
 
     def same_as?(other_address)
@@ -156,49 +156,48 @@ module Spree
     end
 
     private
-      def state_validate
-        # Skip state validation without country (also required)
-        # or when disabled by preference
-        return if country.blank? || !Spree::Config[:address_requires_state]
-        return unless country.states_required
-
-        # ensure associated state belongs to country
-        if state.present?
-          if state.country == country
-            self.state_name = nil #not required as we have a valid state and country combo
-          else
-            if state_name.present?
-              self.state = nil
-            else
-              errors.add(:state, :invalid)
-            end
-          end
+
+    def state_validate
+      # Skip state validation without country (also required)
+      # or when disabled by preference
+      return if country.blank? || !Spree::Config[:address_requires_state]
+      return unless country.states_required
+
+      # ensure associated state belongs to country
+      if state.present?
+        if state.country == country
+          self.state_name = nil # not required as we have a valid state and country combo
+        elsif state_name.present?
+          self.state = nil
+        else
+          errors.add(:state, :invalid)
         end
+      end
+
+      # ensure state_name belongs to country without states, or that it matches a predefined state name/abbr
+      if state_name.present?
+        if country.states.present?
+          states = country.states.find_all_by_name_or_abbr(state_name)
 
-        # ensure state_name belongs to country without states, or that it matches a predefined state name/abbr
-        if state_name.present?
-          if country.states.present?
-            states = country.states.find_all_by_name_or_abbr(state_name)
-
-            if states.size == 1
-              self.state = states.first
-              self.state_name = nil
-            else
-              errors.add(:state, :invalid)
-            end
+          if states.size == 1
+            self.state = states.first
+            self.state_name = nil
+          else
+            errors.add(:state, :invalid)
           end
         end
-
-        # ensure at least one state field is populated
-        errors.add :state, :blank if state.blank? && state_name.blank?
       end
 
-      def postal_code_validate
-        return if country.blank? || country.iso.blank? || !require_zipcode?
-        return if !TwitterCldr::Shared::PostalCodes.territories.include?(country.iso.downcase.to_sym)
+      # ensure at least one state field is populated
+      errors.add :state, :blank if state.blank? && state_name.blank?
+    end
 
-        postal_code = TwitterCldr::Shared::PostalCodes.for_territory(country.iso)
-        errors.add(:zipcode, :invalid) if !postal_code.valid?(zipcode.to_s)
-      end
+    def postal_code_validate
+      return if country.blank? || country.iso.blank? || !require_zipcode?
+      return if !TwitterCldr::Shared::PostalCodes.territories.include?(country.iso.downcase.to_sym)
+
+      postal_code = TwitterCldr::Shared::PostalCodes.for_territory(country.iso)
+      errors.add(:zipcode, :invalid) if !postal_code.valid?(zipcode.to_s)
+    end
   end
 end

data/app/models/spree/adjustment.rb

@@ -17,7 +17,7 @@ module Spree
     belongs_to :adjustable, polymorphic: true, touch: true
     belongs_to :source, polymorphic: true
     belongs_to :order, class_name: 'Spree::Order', inverse_of: :all_adjustments
-    belongs_to :promotion_code, :class_name => 'Spree::PromotionCode'
+    belongs_to :promotion_code, class_name: 'Spree::PromotionCode'
     belongs_to :adjustment_reason, class_name: 'Spree::AdjustmentReason', inverse_of: :adjustments
 
     validates :adjustable, presence: true
@@ -43,7 +43,7 @@ module Spree
     scope :tax, -> { where(source_type: 'Spree::TaxRate') }
     scope :non_tax, -> do
       source_type = arel_table[:source_type]
-      where(source_type.not_eq('Spree::TaxRate').or source_type.eq(nil))
+      where(source_type.not_eq('Spree::TaxRate').or(source_type.eq(nil)))
     end
     scope :price, -> { where(adjustable_type: 'Spree::LineItem') }
     scope :shipping, -> { where(adjustable_type: 'Spree::Shipment') }
@@ -175,10 +175,6 @@ module Spree
       amount
     end
 
-    def currency
-      adjustable ? adjustable.currency : Spree::Config[:currency]
-    end
-
     private
 
     def update_adjustable_adjustment_total

data/app/models/spree/app_configuration.rb

@@ -117,10 +117,21 @@ module Spree
     preference :currency, :string, default: "USD"
 
     # @!attribute [rw] default_country_id
-    #   @deprecated
+    #   @deprecated Use the default country ISO preference instead
     #   @return [Integer,nil] id of {Country} to be selected by default in dropdowns (default: nil)
     preference :default_country_id, :integer
 
+    # @!attribute [rw] default_country_iso
+    #   Default customer country ISO code
+    #   @return [String] Two-letter ISO code of a {Spree::Country} to assumed as the country of an unidentified customer (default: "US")
+    preference :default_country_iso, :string, default: 'US'
+
+    # @!attribute [rw] admin_vat_country_iso
+    #   Set this if you want to enter prices in the backend including value added tax.
+    #   @return [String, nil] Two-letter ISO code of that {Spree::Country} for which
+    #      prices are entered in the backend (default: nil)
+    preference :admin_vat_country_iso, :string, default: nil
+
     # @!attribute [rw] expedited_exchanges
     #   Kicks off an exchange shipment upon return authorization save.
     #   charge customer if they do not return items within timely manner.
@@ -222,7 +233,7 @@ module Spree
 
     # @!attribute [rw] show_raw_product_description
     #   @return [Boolean] Don't escape HTML of product descriptions. (default: +false+)
-    preference :show_raw_product_description, :boolean, :default => false
+    preference :show_raw_product_description, :boolean, default: false
 
     # @!attribute [rw] tax_using_ship_address
     #   @return [Boolean] Use the shipping address rather than the billing address to determine tax (default: +true+)
@@ -243,7 +254,7 @@ module Spree
 
     # @!attribute [rw] mails_from
     #   @return [String] Email address used as +From:+ field in transactional emails.
-    preference :mails_from, :string, :default => 'spree@example.com'
+    preference :mails_from, :string, default: 'spree@example.com'
 
     # Store credits configurations
 
@@ -259,12 +270,38 @@ module Spree
     #   @return [Boolean] Whether use of an address in checkout marks it as user's default
     preference :automatic_default_address, :boolean, default: true
 
+    # @!attribute [rw] can_restrict_stock_management
+    #   @return [Boolean] Indicates if stock management can be restricted by location
+    preference :can_restrict_stock_management, :boolean, default: false
+
     # searcher_class allows spree extension writers to provide their own Search class
     attr_writer :searcher_class
     def searcher_class
       @searcher_class ||= Spree::Core::Search::Base
     end
 
+    # Allows implementing custom pricing for variants
+    # @!attribute [rw] variant_pricer_class
+    # @see Spree::Variant::Pricer
+    # @return [Class] an object that conforms to the API of
+    #   the standard variant pricer class Spree::Variant::Pricer.
+    attr_writer :variant_pricer_class
+    def variant_pricer_class
+      @variant_pricer_class ||= Spree::Variant::Pricer
+    end
+
+    # Shortcut for getting the variant pricer's pricing options class
+    #
+    # @return [Class] The pricing options class to be used
+    delegate :pricing_options_class, to: :variant_pricer_class
+
+    # Shortcut for the default pricing options
+    # @return [variant_pricer_class] An instance of the pricing options class with default desired
+    #   attributes
+    def default_pricing_options
+      @default_pricing_options ||= pricing_options_class.new
+    end
+
     attr_writer :variant_search_class
     def variant_search_class
       @variant_search_class ||= Spree::Core::Search::Variant
@@ -286,6 +323,11 @@ module Spree
       @shipping_rate_selector_class ||= Spree::Stock::ShippingRateSelector
     end
 
+    attr_writer :shipping_rate_taxer_class
+    def shipping_rate_taxer_class
+      @shipping_rate_taxer_class ||= Spree::Tax::ShippingRateTaxer
+    end
+
     # Allows providing your own Mailer for shipped cartons.
     #
     # @!attribute [rw] carton_shipped_email_class
@@ -315,6 +357,19 @@ module Spree
       @stock_configuration ||= Spree::Core::StockConfiguration.new
     end
 
+    # Default admin VAT location
+    #
+    # An object that responds to :state_id and :country_id so it can double as a Spree::Address in
+    # Spree::Zone.for_address. Takes the `admin_vat_country_iso` as input.
+    #
+    # @see admin_vat_country_iso The admin VAT country
+    # @return [Spree::Tax::TaxLocation] default tax location
+    def admin_vat_location
+      @default_tax_location ||= Spree::Tax::TaxLocation.new(
+        country: Spree::Country.find_by(iso: admin_vat_country_iso)
+      )
+    end
+
     # all the following can be deprecated when store prefs are no longer supported
     # @private
     DEPRECATED_STORE_PREFERENCES = {
@@ -322,7 +377,7 @@ module Spree
       site_url: :url,
       default_meta_description: :meta_description,
       default_meta_keywords: :meta_keywords,
-      default_seo_title: :seo_title,
+      default_seo_title: :seo_title
     }
 
     DEPRECATED_STORE_PREFERENCES.each do |old_preference_name, store_method|
@@ -333,7 +388,7 @@ module Spree
       # support all the old preference methods with a warning
       define_method "preferred_#{old_preference_name}" do
         ActiveSupport::Deprecation.warn("#{old_preference_name} is no longer supported on Spree::Config, please access it through #{store_method} on Spree::Store", bc.clean(caller))
-        Store.default.send(store_method)
+        Spree::Store.default.send(store_method)
       end
     end
   end

data/app/models/spree/base.rb

@@ -20,7 +20,7 @@ class Spree::Base < ActiveRecord::Base
   end
 
   if Kaminari.config.page_method_name != :page
-    def self.page num
+    def self.page(num)
       send Kaminari.config.page_method_name, num
     end
   end

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

@@ -2,6 +2,8 @@ require_dependency 'spree/calculator'
 
 module Spree
   class Calculator::DefaultTax < Calculator
+    include Spree::Tax::TaxHelpers
+
     def self.description
       Spree.t(:default_tax)
     end
@@ -10,58 +12,60 @@ module Spree
     # 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)
+      line_items_total = matched_line_items.sum(&:discounted_amount)
       if rate.included_in_price
-        round_to_two_places(line_items_total - ( line_items_total / (1 + rate.amount) ) )
+        order_tax_amount = round_to_two_places(line_items_total - ( line_items_total / (1 + rate.amount) ) )
+        refund_if_necessary(order_tax_amount, order.tax_zone)
       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)
+    def compute_item(item)
       if rate.included_in_price
-        deduced_total_by_rate(item.pre_tax_amount, rate)
+        deduced_total_by_rate(item, rate)
       else
         round_to_two_places(item.discounted_amount * rate.amount)
       end
     end
 
-    alias_method :compute_shipment, :compute_shipment_or_line_item
-    alias_method :compute_line_item, :compute_shipment_or_line_item
-
-    def compute_shipping_rate(shipping_rate)
-      if rate.included_in_price
-        pre_tax_amount = shipping_rate.cost / (1 + rate.amount)
-        if rate.zone == shipping_rate.shipment.order.tax_zone
-          deduced_total_by_rate(pre_tax_amount, rate)
-        else
-          deduced_total_by_rate(pre_tax_amount, rate) * - 1
-        end
-      else
-        with_tax_amount = shipping_rate.cost * rate.amount
-        round_to_two_places(with_tax_amount)
-      end
-    end
+    alias_method :compute_shipment, :compute_item
+    alias_method :compute_line_item, :compute_item
+    alias_method :compute_shipping_rate, :compute_item
 
     private
 
     def rate
-      self.calculable
+      calculable
     end
 
     def round_to_two_places(amount)
       BigDecimal.new(amount.to_s).round(2, BigDecimal::ROUND_HALF_UP)
     end
 
-    def deduced_total_by_rate(pre_tax_amount, rate)
-      round_to_two_places(pre_tax_amount * rate.amount)
+    def deduced_total_by_rate(item, rate)
+      unrounded_net_amount = item.discounted_amount / (1 + sum_of_included_tax_rates(item))
+      refund_if_necessary(
+        round_to_two_places(unrounded_net_amount * rate.amount),
+        item.order.tax_zone
+      )
+    end
+
+    def refund_if_necessary(amount, order_tax_zone)
+      if default_zone_or_zone_match?(order_tax_zone)
+        amount
+      else
+        amount * -1
+      end
     end
 
+    def default_zone_or_zone_match?(order_tax_zone)
+      Zone.default_tax.try!(:contains?, order_tax_zone) || rate.zone.contains?(order_tax_zone)
+    end
   end
 end

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

@@ -9,7 +9,7 @@ module Spree
     end
 
     def compute(object)
-      computed_amount  = (object.amount * preferred_flat_percent / 100).round(2)
+      computed_amount = (object.amount * preferred_flat_percent / 100).round(2)
 
       # We don't want to cause the promotion adjustments to push the order into a negative total.
       if computed_amount > object.amount

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

@@ -9,8 +9,8 @@ module Spree
       Spree.t(:flat_rate_per_order)
     end
 
-    def compute(object=nil)
-      if object && preferred_currency.upcase == object.currency.upcase
+    def compute(object = nil)
+      if object && preferred_currency.casecmp(object.currency).zero?
         preferred_amount
       else
         0