solidus_core 1.0.7 → 1.1.0.beta1

data/app/models/spree/address.rb

@@ -5,11 +5,7 @@ module Spree
     belongs_to :country, class_name: "Spree::Country"
     belongs_to :state, class_name: "Spree::State"
 
-    has_many :shipments, inverse_of: :address
-    has_many :cartons, inverse_of: :address
-    has_many :credit_cards, inverse_of: :address
-
-    validates :firstname, :lastname, :address1, :city, :country, presence: true
+    validates :firstname, :lastname, :address1, :city, :country_id, presence: true
     validates :zipcode, presence: true, if: :require_zipcode?
     validates :phone, presence: true, if: :require_phone?
 
@@ -18,22 +14,70 @@ module Spree
     alias_attribute :first_name, :firstname
     alias_attribute :last_name, :lastname
 
+    DB_ONLY_ATTRS = %w(id updated_at created_at)
 
     self.whitelisted_ransackable_attributes = %w[firstname lastname]
 
+    scope :with_values, ->(attributes) do
+      where(value_attributes(attributes))
+    end
+
     def self.build_default
-      country = Spree::Country.find(Spree::Config[:default_country_id]) rescue Spree::Country.first
-      new(country: country)
+      new(country: Spree::Country.default)
     end
 
     def self.default(user = nil, kind = "bill")
-      if user && user_address = user.send(:"#{kind}_address")
-        user_address.dup
+      ActiveSupport::Deprecation.warn("Address.default is deprecated. Use User.default_address or Address.build_default", caller)
+      if user
+        user.send(:"#{kind}_address") || build_default
       else
         build_default
       end
     end
 
+    # @return [Address] an equal address already in the database or a newly created one
+    def self.factory(attributes)
+      full_attributes = value_attributes(column_defaults, new(attributes).attributes)
+      find_or_initialize_by(full_attributes)
+    end
+
+    # @return [Address] address from existing address plus new_attributes as diff
+    # @note, this may return existing_address if there are no changes to value equality
+    def self.immutable_merge(existing_address, new_attributes)
+      return factory(new_attributes) if existing_address.nil?
+
+      merged_attributes = value_attributes(existing_address.attributes, new_attributes)
+      new_address = factory(merged_attributes)
+      if existing_address == new_address
+        existing_address
+      else
+        new_address
+      end
+    end
+
+    # @return [Hash] hash of attributes contributing to value equality with optional merge
+    def self.value_attributes(base_attributes, merge_attributes = nil)
+      # dup because we may modify firstname/lastname.
+      base = base_attributes.dup
+
+      base.stringify_keys!
+
+      if merge_attributes
+        base.merge!(merge_attributes.stringify_keys)
+      end
+
+      # TODO: Deprecate these aliased attributes
+      base['firstname'] = base.delete('first_name') if base.key?('first_name')
+      base['lastname'] = base.delete('last_name') if base.key?('last_name')
+
+      base.except!(*DB_ONLY_ATTRS)
+    end
+
+    # @return [Hash] hash of attributes contributing to value equality
+    def value_attributes
+      self.class.value_attributes(attributes)
+    end
+
     # @return [String] the full name on this address
     def full_name
       "#{firstname} #{lastname}".strip
@@ -44,45 +88,30 @@ module Spree
       state.try(:abbr) || state.try(:name) || state_name
     end
 
-    # @param other [Spree::Address, nil] the address we are comparing with
-    # @return [Boolean] true if this fields on this address match the fields on
-    #   the other address
-    def same_as?(other)
-      return false if other.nil?
-      attributes.except('id', 'updated_at', 'created_at') == other.attributes.except('id', 'updated_at', 'created_at')
-    end
-
-    alias same_as same_as?
-
-    # @return [String] the full name on the address followed by the first line
-    #   of the address
     def to_s
       "#{full_name}: #{address1}"
     end
 
-    # @return [Spree::Address] a new address that is the same_as? this address
-    def clone
-      ActiveSupport::Deprecation.warn "Spree::Address.clone is deprecated and may be removed from future releases, Use Spree::Address.dup instead", caller
-      self.dup
-    end
-
     # @note This compares the addresses based on only the fields that make up
-    #   the logical "address" and excludes their order IDs. Use #same_as? to
-    #   include the order IDs in the comparison
+    #   the logical "address" and excludes the database specific fields (id, created_at, updated_at).
     # @return [Boolean] true if the two addresses have the same address fields
     def ==(other_address)
-      self_attrs = self.attributes
-      other_attrs = other_address.respond_to?(:attributes) ? other_address.attributes : {}
+      return false unless other_address && other_address.respond_to?(:value_attributes)
+      self.value_attributes == other_address.value_attributes
+    end
 
-      [self_attrs, other_attrs].each { |attrs| attrs.except!('id', 'created_at', 'updated_at', 'order_id') }
+    def same_as?(other_address)
+      ActiveSupport::Deprecation.warn("Address.same_as? is deprecated. It's equivalent to Address.==", caller)
+      self == other_address
+    end
 
-      self_attrs == other_attrs
+    def same_as(other_address)
+      ActiveSupport::Deprecation.warn("Address.same_as is deprecated. It's equivalent to Address.==", caller)
+      self == other_address
     end
 
-    # @return [Boolean] true if the order is missing all of the address fields
-    #   are nil
     def empty?
-      attributes.except('id', 'created_at', 'updated_at', 'order_id', 'country_id').all? { |_, v| v.nil? }
+      attributes.except('id', 'created_at', 'updated_at', 'country_id').all? { |_, v| v.nil? }
     end
 
     # @return [Hash] an ActiveMerchant compatible address hash
@@ -112,6 +141,20 @@ module Spree
       true
     end
 
+    # This is set in order to preserve immutability of Addresses. Use #dup to create
+    # new records as required, but it probably won't be required as often as you think.
+    # Since addresses do not change, you won't accidentally alter historical data.
+    def readonly?
+      persisted?
+    end
+
+    # @param iso [String] 2 letter Country ISO
+    # @return [Country] setter that sets self.country to the Country with a matching 2 letter iso
+    # @raise [ActiveRecord::RecordNotFound] if country with the iso doesn't exist
+    def country_iso=(iso)
+      self.country = Country.find_by!(iso: iso)
+    end
+
     private
       def state_validate
         # Skip state validation without country (also required)

data/app/models/spree/adjustment.rb

@@ -7,16 +7,7 @@ module Spree
   #
   # == Boolean attributes
   #
-  # 1. *mandatory*
-  #
-  #    If this flag is set to true then it means the the charge is required and
-  #    will not be removed from the order, even if the amount is zero. In other
-  #    words a record will be created even if the amount is zero. This is
-  #    useful for representing things such as shipping and tax charges where
-  #    you may want to make it explicitly clear that no charge was made for
-  #    such things.
-  #
-  # 2. *eligible?*
+  # 1. *eligible?*
   #
   #    This boolean attributes stores whether this adjustment is currently
   #    eligible for its order. Only eligible adjustments count towards the
@@ -35,21 +26,19 @@ module Spree
     validates :amount, numericality: true
     validates :promotion_code, presence: true, if: :require_promotion_code?
 
-    state_machine :state, initial: :open do
-      event :close do
-        transition from: :open, to: :closed
-      end
-
-      event :open do
-        transition from: :closed, to: :open
-      end
-    end
-
     after_create :update_adjustable_adjustment_total
     after_destroy :update_adjustable_adjustment_total
 
-    scope :open, -> { where(state: 'open') }
-    scope :closed, -> { where(state: 'closed') }
+    scope :not_finalized, -> { where(finalized: false) }
+    scope :open, -> do
+      ActiveSupport::Deprecation.warn "Adjustment.open is deprecated. Instead use Adjustment.not_finalized", caller
+      where(finalized: false)
+    end
+    scope :finalized, -> { where(finalized: true) }
+    scope :closed, -> do
+      ActiveSupport::Deprecation.warn "Adjustment.closed is deprecated. Instead use Adjustment.finalized", caller
+      where(finalized: true)
+    end
     scope :cancellation, -> { where(source_type: 'Spree::UnitCancel') }
     scope :tax, -> { where(source_type: 'Spree::TaxRate') }
     scope :non_tax, -> do
@@ -58,7 +47,6 @@ module Spree
     end
     scope :price, -> { where(adjustable_type: 'Spree::LineItem') }
     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") }
@@ -72,9 +60,70 @@ module Spree
     extend DisplayMoney
     money_methods :amount
 
+    def finalize!
+      update_attributes!(finalized: true)
+    end
+
+    def unfinalize!
+      update_attributes!(finalized: false)
+    end
+
+    def finalize
+      update_attributes(finalized: true)
+    end
+
+    def unfinalize
+      update_attributes(finalized: false)
+    end
+
+    # Deprecated methods
+    def state
+      ActiveSupport::Deprecation.warn "Adjustment#state is deprecated. Instead use Adjustment#finalized?", caller
+      finalized? ? "closed" : "open"
+    end
+
+    def state=(new_state)
+      ActiveSupport::Deprecation.warn "Adjustment#state= is deprecated. Instead use Adjustment#finalized=", caller
+      case new_state
+      when "open"
+        self.finalized = false
+      when "closed"
+        self.finalized = true
+      else
+        raise "invaliid adjustment state #{new_state}"
+      end
+    end
+
+    def open?
+      ActiveSupport::Deprecation.warn "Adjustment#open? is deprecated. Instead use Adjustment#finalized?", caller
+      !closed?
+    end
+
     def closed?
-      state == "closed"
+      ActiveSupport::Deprecation.warn "Adjustment#closed? is deprecated. Instead use Adjustment#finalized?", caller
+      finalized?
+    end
+
+    def open
+      ActiveSupport::Deprecation.warn "Adjustment#open is deprecated. Instead use Adjustment#unfinalize", caller
+      unfinalize
+    end
+
+    def open!
+      ActiveSupport::Deprecation.warn "Adjustment#open! is deprecated. Instead use Adjustment#unfinalize!", caller
+      unfinalize!
+    end
+
+    def close
+      ActiveSupport::Deprecation.warn "Adjustment#close is deprecated. Instead use Adjustment#finalize", caller
+      finalize
+    end
+
+    def close!
+      ActiveSupport::Deprecation.warn "Adjustment#close! is deprecated. Instead use Adjustment#finalize!", caller
+      finalize!
     end
+    # End deprecated methods
 
     def currency
       adjustable ? adjustable.currency : Spree::Config[:currency]
@@ -107,7 +156,7 @@ module Spree
       if target
         ActiveSupport::Deprecation.warn("Passing a target to Adjustment#update! is deprecated. The adjustment will use the correct target from it's adjustable association.", caller)
       end
-      return amount if closed?
+      return amount if finalized?
 
       # 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.

data/app/models/spree/adjustment_reason.rb

@@ -1,5 +1,5 @@
 module Spree
-  class AdjustmentReason < ActiveRecord::Base
+  class AdjustmentReason < Spree::Base
     has_many :adjustments, inverse_of: :adjustment_reason
 
     validates :name, presence: true

data/app/models/spree/app_configuration.rb

@@ -80,9 +80,25 @@ module Spree
     #   quantity. Setting this to true should make operations on inventory
     #   faster.
     #   (default: +false+)
+    #   @deprecated - use inventory_cache_threshold instead
     #   @return [Boolean]
     preference :binary_inventory_cache, :boolean, default: false
 
+    # @!attribute [rw] completable_order_created_cutoff
+    #   @return [Integer] the number of days to look back for created orders which get returned to the user as last completed
+    preference :completable_order_created_cutoff_days, :integer, default: nil
+
+    # @!attribute [rw] completable_order_created_cutoff
+    #   @return [Integer] the number of days to look back for updated orders which get returned to the user as last completed
+    preference :completable_order_updated_cutoff_days, :integer, default: nil
+
+    # @!attribute [rw] inventory_cache_threshold
+    #   Only invalidate product caches when the count on hand for a stock item
+    #   falls below or rises about the inventory_cache_threshold.  When undefined, the
+    #   product caches will be invalidated anytime the count on hand is changed.
+    #   @return [Integer]
+    preference :inventory_cache_threshold, :integer
+
     # @!attribute [rw] checkout_zone
     #   @return [String] Name of a {Zone}, which limits available countries to those included in that zone. (default: +nil+)
     preference :checkout_zone, :string, default: nil
@@ -224,12 +240,31 @@ module Spree
     #   @return [Boolean] Creates a new allocation anytime {StoreCredit#credit} is called
     preference :credit_to_new_allocation, :boolean, default: false
 
+    # @!attribute [rw] automatic_default_address
+    #   The default value of true preserves existing backwards compatible feature of
+    #   treating the most recently used address in checkout as the user's default address.
+    #   Setting to false means that the user should manage their own default via some
+    #   custom UI that uses AddressBookController.
+    #   @return [Boolean] Whether use of an address in checkout marks it as user's default
+    preference :automatic_default_address, :boolean, default: true
+
     # 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
 
+    attr_writer :variant_search_class
+    def variant_search_class
+      @variant_search_class ||= Spree::Core::Search::Variant
+    end
+
+    # promotion_chooser_class allows extensions to provide their own PromotionChooser
+    attr_writer :promotion_chooser_class
+    def promotion_chooser_class
+      @promotion_chooser_class ||= Spree::PromotionChooser
+    end
+
     def static_model_preferences
       @static_model_preferences ||= Spree::Preferences::StaticModelPreferences.new
     end

data/app/models/spree/carton.rb

@@ -1,5 +1,5 @@
-class Spree::Carton < ActiveRecord::Base
-  belongs_to :address, class_name: 'Spree::Address', inverse_of: :cartons
+class Spree::Carton < Spree::Base
+  belongs_to :address, class_name: 'Spree::Address'
   belongs_to :stock_location, class_name: 'Spree::StockLocation', inverse_of: :cartons
   belongs_to :shipping_method, class_name: 'Spree::ShippingMethod', inverse_of: :cartons
 
@@ -48,7 +48,7 @@ class Spree::Carton < ActiveRecord::Base
   end
 
   def manifest_for_order(order)
-    Spree::ShippingManifest.new(inventory_units: (inventory_units & order.inventory_units)).items
+    Spree::ShippingManifest.new(inventory_units: inventory_units).for_order(order).items
   end
 
   def any_exchanges?

data/app/models/spree/country.rb

@@ -1,6 +1,6 @@
 module Spree
   class Country < Spree::Base
-    has_many :states, -> { order('name ASC') }, dependent: :destroy
+    has_many :states, -> { order(:name) }, dependent: :destroy
     has_many :addresses, dependent: :nullify
 
     validates :name, :iso_name, presence: true
@@ -12,6 +12,12 @@ module Spree
       states_required
     end
 
+    def self.default
+      find(Spree::Config[:default_country_id])
+    rescue ActiveRecord::RecordNotFound
+      first
+    end
+
     def <=>(other)
       name <=> other.name
     end

data/app/models/spree/credit_card.rb

@@ -2,7 +2,7 @@ module Spree
   class CreditCard < Spree::Base
     belongs_to :payment_method
     belongs_to :user, class_name: Spree.user_class, foreign_key: 'user_id'
-    belongs_to :address, inverse_of: :credit_cards
+    belongs_to :address
     has_many :payments, as: :source
 
     before_save :set_last_digits
@@ -36,6 +36,10 @@ module Spree
       jcb: /^(?:2131|1800|35\d{3})\d{11}$/
     }
 
+    def address_attributes=(attributes)
+      self.address = Address.immutable_merge(address, attributes)
+    end
+
     # Sets the expiry date on this credit card.
     #
     # @param expiry [String] the desired new expiry date in one of the

data/app/models/spree/gateway.rb

@@ -29,14 +29,6 @@ module Spree
       preferences.to_hash
     end
 
-    def method_missing(method, *args)
-      if provider.nil? || !provider.respond_to?(method)
-        super
-      else
-        provider.send(method, *args)
-      end
-    end
-
     def payment_profiles_supported?
       false
     end

data/app/models/spree/inventory_unit.rb

@@ -33,7 +33,7 @@ module Spree
         .where("spree_shipments.state != 'canceled'").references(:shipment)
         .where(variant_id: stock_item.variant_id)
         .where('spree_orders.completed_at is not null')
-        .backordered.order("spree_orders.completed_at ASC")
+        .backordered.order(Spree::Order.arel_table[:completed_at].asc)
     end
     scope :shippable, -> { on_hand }