solidus_core_devise_token_auth 2.8.0.alpha.0

data/app/models/spree/address.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+module Spree
+  # `Spree::Address` provides the foundational ActiveRecord model for recording and
+  # validating address information for `Spree::Order`, `Spree::Shipment`,
+  # `Spree::UserAddress`, and `Spree::Carton`.
+  #
+  class Address < Spree::Base
+    extend ActiveModel::ForbiddenAttributesProtection
+
+    belongs_to :country, class_name: "Spree::Country"
+    belongs_to :state, class_name: "Spree::State"
+
+    validates :firstname, :address1, :city, :country_id, presence: true
+    validates :zipcode, presence: true, if: :require_zipcode?
+    validates :phone, presence: true, if: :require_phone?
+
+    validate :state_validate
+    validate :validate_state_matches_country
+
+    alias_attribute :first_name, :firstname
+    alias_attribute :last_name, :lastname
+
+    DB_ONLY_ATTRS = %w(id updated_at created_at)
+    TAXATION_ATTRS = %w(state_id country_id zipcode)
+
+    self.whitelisted_ransackable_attributes = %w[firstname lastname]
+
+    scope :with_values, ->(attributes) do
+      where(value_attributes(attributes))
+    end
+
+    def self.build_default
+      new(country: Spree::Country.default)
+    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)
+      # Ensure new_attributes is a sanitized hash
+      new_attributes = sanitize_for_mass_assignment(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
+
+    def taxation_attributes
+      self.class.value_attributes(attributes.slice(*TAXATION_ATTRS))
+    end
+
+    # @return [String] the full name on this address
+    def full_name
+      "#{firstname} #{lastname}".strip
+    end
+
+    # @return [String] a string representation of this state
+    def state_text
+      state.try(:abbr) || state.try(:name) || state_name
+    end
+
+    def to_s
+      "#{full_name}: #{address1}"
+    end
+
+    # @note This compares the addresses based on only the fields that make up
+    #   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)
+      return false unless other_address && other_address.respond_to?(:value_attributes)
+      value_attributes == other_address.value_attributes
+    end
+
+    # @deprecated Do not use this. Use Address.== instead.
+    def same_as?(other_address)
+      Spree::Deprecation.warn("Address#same_as? is deprecated. It's equivalent to Address.==", caller)
+      self == other_address
+    end
+
+    # @deprecated Do not use this. Use Address.== instead.
+    def same_as(other_address)
+      Spree::Deprecation.warn("Address#same_as is deprecated. It's equivalent to Address.==", caller)
+      self == other_address
+    end
+
+    # @deprecated Do not use this
+    def empty?
+      Spree::Deprecation.warn("Address#empty? is deprecated.", caller)
+      attributes.except('id', 'created_at', 'updated_at', 'country_id').all? { |_, v| v.nil? }
+    end
+
+    # This exists because the default Object#blank?, checks empty? if it is
+    # defined, and we have defined empty.
+    # This should be removed once empty? is removed
+    def blank?
+      false
+    end
+
+    # @return [Hash] an ActiveMerchant compatible address hash
+    def active_merchant_hash
+      {
+        name: full_name,
+        address1: address1,
+        address2: address2,
+        city: city,
+        state: state_text,
+        zip: zipcode,
+        country: country.try(:iso),
+        phone: phone
+      }
+    end
+
+    # @todo Remove this from the public API if possible.
+    # @return [true] whether or not the address requires a phone number to be
+    #   valid
+    def require_phone?
+      true
+    end
+
+    # @todo Remove this from the public API if possible.
+    # @return [true] whether or not the address requires a zipcode to be valid
+    def require_zipcode?
+      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 = Spree::Country.find_by!(iso: iso)
+    end
+
+    def country_iso
+      country && country.iso
+    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
+        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.with_name_or_abbr(state_name)
+
+          if states.size == 1
+            self.state = states.first
+            self.state_name = nil
+          else
+            errors.add(:state, :invalid)
+          end
+        end
+      end
+
+      # ensure at least one state field is populated
+      errors.add :state, :blank if state.blank? && state_name.blank?
+    end
+
+    def validate_state_matches_country
+      if state && state.country != country
+        errors.add(:state, :does_not_match_country)
+      end
+    end
+  end
+end

data/app/models/spree/adjustment.rb

@@ -0,0 +1,168 @@
+# frozen_string_literal: true
+
+module Spree
+  # 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 "opened" or "closed". Once an adjustment is closed, it
+  # will not be automatically updated.
+  #
+  # == Boolean attributes
+  #
+  # 1. *eligible?*
+  #
+  #    This boolean attributes stores whether this adjustment is currently
+  #    eligible for its order. Only eligible adjustments count towards the
+  #    order's adjustment total. This allows an adjustment to be preserved if
+  #    it becomes ineligible so it might be reinstated.
+  class Adjustment < Spree::Base
+    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 :adjustment_reason, class_name: 'Spree::AdjustmentReason', inverse_of: :adjustments
+
+    validates :adjustable, presence: true
+    validates :order, presence: true
+    validates :label, presence: true
+    validates :amount, numericality: true
+    validates :promotion_code, presence: true, if: :require_promotion_code?
+
+    # We need to use `after_commit` here because otherwise it's too early to
+    # tell if any repair is needed.
+    after_commit :repair_adjustments_associations_on_create, on: [:create]
+    after_commit :repair_adjustments_associations_on_destroy, on: [:destroy]
+
+    scope :not_finalized, -> { where(finalized: false) }
+    scope :finalized, -> { where(finalized: true) }
+    scope :cancellation, -> { where(source_type: 'Spree::UnitCancel') }
+    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)))
+    end
+    scope :price, -> { where(adjustable_type: 'Spree::LineItem') }
+    scope :shipping, -> { where(adjustable_type: 'Spree::Shipment') }
+    scope :eligible, -> { where(eligible: true) }
+    scope :charge, -> { where("#{quoted_table_name}.amount >= 0") }
+    scope :credit, -> { where("#{quoted_table_name}.amount < 0") }
+    scope :nonzero, -> { where("#{quoted_table_name}.amount != 0") }
+    scope :promotion, -> { where(source_type: 'Spree::PromotionAction') }
+    scope :non_promotion, -> { where.not(source_type: 'Spree::PromotionAction') }
+    scope :return_authorization, -> { where(source_type: "Spree::ReturnAuthorization") }
+    scope :is_included, -> { where(included: true) }
+    scope :additional, -> { where(included: false) }
+
+    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
+
+    def currency
+      adjustable ? adjustable.currency : Spree::Config[:currency]
+    end
+
+    # @return [Boolean] true when this is a promotion adjustment (Promotion adjustments have a {PromotionAction} source)
+    def promotion?
+      source_type == 'Spree::PromotionAction'
+    end
+
+    # @return [Boolean] true when this is a tax adjustment (Tax adjustments have a {TaxRate} source)
+    def tax?
+      source_type == 'Spree::TaxRate'
+    end
+
+    # @return [Boolean] true when this is a cancellation adjustment (Cancellation adjustments have a {UnitCancel} source)
+    def cancellation?
+      source_type == 'Spree::UnitCancel'
+    end
+
+    # Recalculate and persist the amount from this adjustment's source based on
+    # the adjustable ({Order}, {Shipment}, or {LineItem})
+    #
+    # If the adjustment has no source (such as when created manually from the
+    # admin) or is closed, this is a noop.
+    #
+    # @return [BigDecimal] New amount of this adjustment
+    def recalculate
+      if finalized? && !tax?
+        return amount
+      end
+
+      # If the adjustment has no source, do not attempt to re-calculate the
+      # amount.
+      # Some scenarios where this happens:
+      #   - Adjustments that are manually created via the admin backend
+      #   - PromotionAction adjustments where the PromotionAction was deleted
+      #     after the order was completed.
+      if source.present?
+        self.amount = source.compute_amount(adjustable)
+
+        if promotion?
+          self.eligible = calculate_eligibility
+        end
+
+        # Persist only if changed
+        # This is only not a save! to avoid the extra queries to load the order
+        # (for validations) and to touch the adjustment.
+        update_columns(eligible: eligible, amount: amount, updated_at: Time.current) if changed?
+      end
+      amount
+    end
+
+    def update!(*args)
+      if args.empty?
+        Spree::Deprecation.warn "Calling adjustment.update! with no arguments to recalculate amounts and eligibility is deprecated, since it conflicts with AR::Base#update! Please use adjustment.recalculate instead"
+        recalculate
+      else
+        super
+      end
+    end
+
+    # Calculates based on attached promotion (if this is a promotion
+    # adjustment) whether this promotion is still eligible.
+    # @api private
+    # @return [true,false] Whether this adjustment is eligible
+    def calculate_eligibility
+      if !finalized? && source && promotion?
+        source.promotion.eligible?(adjustable, promotion_code: promotion_code)
+      else
+        eligible?
+      end
+    end
+
+    private
+
+    def require_promotion_code?
+      promotion? && source.promotion.codes.any?
+    end
+
+    def repair_adjustments_associations_on_create
+      if adjustable.adjustments.loaded? && !adjustable.adjustments.include?(self) && !destroyed?
+        Spree::Deprecation.warn("Adjustment #{id} was not added to #{adjustable.class} #{adjustable.id}. Add adjustments via `adjustable.adjustments.create!`. Partial call stack: #{caller.select { |line| line =~ %r(/(app|spec)/) }}.", caller)
+        adjustable.adjustments.proxy_association.add_to_target(self)
+      end
+    end
+
+    def repair_adjustments_associations_on_destroy
+      if adjustable.adjustments.loaded? && adjustable.adjustments.include?(self)
+        Spree::Deprecation.warn("Adjustment #{id} was not removed from #{adjustable.class} #{adjustable.id}. Remove adjustments via `adjustable.adjustments.destroy`. Partial call stack: #{caller.select { |line| line =~ %r(/(app|spec)/) }}.", caller)
+        adjustable.adjustments.proxy_association.target.delete(self)
+      end
+    end
+  end
+end

data/app/models/spree/adjustment_reason.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Spree
+  class AdjustmentReason < Spree::Base
+    has_many :adjustments, inverse_of: :adjustment_reason
+
+    validates :name, presence: true, uniqueness: { case_sensitive: false, allow_blank: true }
+    validates :code, presence: true, uniqueness: { case_sensitive: false, allow_blank: true }
+
+    scope :active, -> { where(active: true) }
+  end
+end

data/app/models/spree/asset.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Spree
+  class Asset < Spree::Base
+    belongs_to :viewable, polymorphic: true, touch: true
+    acts_as_list scope: [:viewable_id, :viewable_type]
+  end
+end

data/app/models/spree/base.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+class Spree::Base < ActiveRecord::Base
+  include Spree::Preferences::Preferable
+  serialize :preferences, Hash
+
+  include Spree::RansackableAttributes
+
+  self.belongs_to_required_by_default = false
+
+  def initialize_preference_defaults
+    if has_attribute?(:preferences)
+      self.preferences = default_preferences.merge(preferences)
+    end
+  end
+
+  # Only run preference initialization on models which requires it. Improves
+  # performance of record initialization slightly.
+  def self.preference(*args)
+    # after_initialize can be called multiple times with the same symbol, it
+    # will only be called once on initialization.
+    after_initialize :initialize_preference_defaults
+    super
+  end
+
+  if Kaminari.config.page_method_name != :page
+    def self.page(num)
+      Spree::Deprecation.warn \
+        "Redefining Spree::Base.page for a different kaminari page name is better done inside " \
+        "your own app. This will be removed from future versions of solidus."
+
+      send Kaminari.config.page_method_name, num
+    end
+  end
+
+  self.abstract_class = true
+
+  # Provides a scope that should be included any time products
+  # are fetched with the intention of displaying to the user.
+  #
+  # Allows individual stores to include any active record scopes or joins
+  # when products are displayed.
+  def self.display_includes
+    where(nil)
+  end
+end

data/app/models/spree/billing_integration.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Spree
+  class BillingIntegration < PaymentMethod
+    validates :name, presence: true
+
+    preference :server, :string, default: 'test'
+    preference :test_mode, :boolean, default: true
+
+    def gateway
+      integration_options = options
+      ActiveMerchant::Billing::Base.integration_mode = integration_options[:server].to_sym
+      integration_options[:test] = true if integration_options[:test_mode]
+      @gateway ||= gateway_class.new(integration_options)
+    end
+
+    def options
+      options_hash = {}
+      preferences.each { |key, value| options_hash[key.to_sym] = value }
+      options_hash
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require_dependency 'spree/calculator'
+
+module Spree
+  class Calculator::DefaultTax < Calculator
+    include Spree::Tax::TaxHelpers
+
+    # 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)
+      return 0 unless rate.active?
+      matched_line_items = order.line_items.select do |line_item|
+        rate.tax_categories.include?(line_item.tax_category)
+      end
+
+      line_items_total = matched_line_items.sum(&:total_before_tax)
+      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_item(item)
+      return 0 unless rate.active?
+      if rate.included_in_price
+        deduced_total_by_rate(item, rate)
+      else
+        round_to_two_places(item.total_before_tax * rate.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
+      calculable
+    end
+
+    def round_to_two_places(amount)
+      BigDecimal(amount.to_s).round(2, BigDecimal::ROUND_HALF_UP)
+    end
+
+    def deduced_total_by_rate(item, rate)
+      round_to_two_places(
+        rate.amount * item.total_before_tax / (1 + sum_of_included_tax_rates(item))
+      )
+    end
+
+    def sum_of_included_tax_rates(item)
+      rates_for_item(item).map(&:amount).sum
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_dependency 'spree/calculator'
+
+# This is a calculator for line item adjustment actions. It accepts a line item
+# and calculates its weighted adjustment amount based on the value of the
+# preferred amount and the price of the other line items. More expensive line
+# items will receive a greater share of the preferred amount.
+
+module Spree
+  class Calculator::DistributedAmount < Calculator
+    preference :amount, :decimal, default: 0
+    preference :currency, :string, default: -> { Spree::Config[:currency] }
+
+    def compute_line_item(line_item)
+      return 0 unless line_item
+      return 0 unless preferred_currency.casecmp(line_item.currency).zero?
+      return 0 unless calculable.promotion.line_item_actionable?(line_item.order, line_item)
+      Spree::DistributedAmountsHandler.new(
+        actionable_line_items(line_item.order),
+        preferred_amount
+      ).amount(line_item)
+    end
+
+    private
+
+    def actionable_line_items(order)
+      order.line_items.select do |line_item|
+        calculable.promotion.line_item_actionable?(order, line_item)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require_dependency 'spree/calculator'
+
+module Spree
+  class Calculator::FlatPercentItemTotal < Calculator
+    preference :flat_percent, :decimal, default: 0
+
+    def compute(object)
+      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
+        object.amount
+      else
+        computed_amount
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_dependency 'spree/calculator'
+
+module Spree
+  class Calculator::FlatRate < Calculator
+    preference :amount, :decimal, default: 0
+    preference :currency, :string, default: ->{ Spree::Config[:currency] }
+
+    def compute(object = nil)
+      if object && preferred_currency.casecmp(object.currency).zero?
+        preferred_amount
+      else
+        0
+      end
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require_dependency 'spree/calculator'
+
+module Spree
+  class Calculator::FlexiRate < Calculator
+    preference :first_item,      :decimal, default: 0
+    preference :additional_item, :decimal, default: 0
+    preference :max_items,       :integer, default: 0
+    preference :currency,        :string,  default: ->{ Spree::Config[:currency] }
+
+    def self.available?(_object)
+      Spree::Deprecation.warn('Spree::Calculator::FlexiRate::available is DEPRECATED. Use the instance method instead.')
+      true
+    end
+
+    def compute(object)
+      items_count = object.quantity
+      items_count = [items_count, preferred_max_items].min unless preferred_max_items.zero?
+
+      return BigDecimal(0) if items_count == 0
+
+      additional_items_count = items_count - 1
+      preferred_first_item + preferred_additional_item * additional_items_count
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_dependency 'spree/calculator'
+
+module Spree
+  # @deprecated This calculator will be removed in future versions of Spree.
+  #   The only case where it was used was for Free Shipping Promotions.  There is
+  #   now a Promotion Action which deals with these types of promotions instead.
+  class Calculator::FreeShipping < Calculator
+    def compute(object)
+      if object.is_a?(Array)
+        return if object.empty?
+        order = object.first.order
+      else
+        order = object
+      end
+
+      order.ship_total
+    end
+  end
+end

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

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_dependency 'spree/calculator'
+
+module Spree
+  class Calculator::PercentOnLineItem < Calculator
+    preference :percent, :decimal, default: 0
+
+    def compute(object)
+      (object.amount * preferred_percent) / 100
+    end
+  end
+end