spree_core 5.6.0 → 6.0.0.beta1

data/app/models/spree/adjustable/promotion_accumulator.rb

@@ -1,78 +0,0 @@
-module Spree
-  module Adjustable
-    class PromotionAccumulator
-      attr_reader :adjustments, :sources, :promotions
-
-      # Adds accumulator as an attribute of adjustable to
-      # avoid changing number of passed arguments to
-      # adjustment#update! and concequential methods
-      def self.add_to(adjustable)
-        class << adjustable
-          attr_accessor :promotion_accumulator
-        end
-
-        adjustable.promotion_accumulator = new(adjustable)
-      end
-
-      def initialize(adjustable)
-        @adjustable = adjustable
-        @adjustments = []
-        @sources = []
-        @promotions = []
-        all_adjustments.each { |a| add_adjustment(a) }
-      end
-
-      def add_adjustment(adjustment, opts = {})
-        return unless adjustment.promotion?
-
-        source = opts[:source] || adjustment.source
-        promotion = opts[:promotion] || source.promotion
-
-        add(adjustments, adjustment, adjustment.id)
-        add(sources, source, adjustment.source_id)
-        add(promotions, promotion, source.promotion_id)
-      end
-
-      def promotions_adjustments(promotion_id, adjustments = self.adjustments)
-        where(sources, promotion_id: promotion_id).map do |source|
-          where(adjustments, source_id: source.id)
-        end.flatten
-      end
-
-      def promo_total(*args)
-        promotions_adjustments(*args).map(&:amount).reduce(0, &:+)
-      end
-
-      def total_with_promotion(promotion_id)
-        amount + ship_total + promo_total(promotion_id)
-      end
-
-      def item_total_with_promotion(promotion_id)
-        amount + promo_total(promotion_id, item_adjustments)
-      end
-
-      private
-
-      attr_reader :adjustable
-      delegate :order, to: :adjustable
-      delegate :amount, :ship_total, to: :order
-
-      def all_adjustments
-        order.all_adjustments.promotion.includes(source: [:promotion]).where.
-          not('adjustable_id = ? AND adjustable_type = ?', adjustable.id, adjustable.class.to_s)
-      end
-
-      def add(array, object, id)
-        array << object if array.none? { |a| a.id == id }
-      end
-
-      def item_adjustments
-        adjustments.reject { |a| a.adjustable_type == 'Spree::Shipment' }
-      end
-
-      def where(array, opts = {})
-        array.select { |a| opts.all? { |k, v| a.respond_to?(k) && a.send(k) == v } }
-      end
-    end
-  end
-end

data/app/models/spree/adjustment.rb

@@ -1,130 +0,0 @@
-# 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:
-#
-# +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.
-#
-# +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.
-module Spree
-  class Adjustment < Spree.base_class
-    has_prefix_id :adj  # Spree-specific: adjustment
-
-    with_options polymorphic: true do
-      belongs_to :adjustable, touch: true
-      belongs_to :source
-    end
-    belongs_to :order, class_name: 'Spree::Order', inverse_of: :all_adjustments
-    belongs_to :promotion_action, class_name: 'Spree::PromotionAction', foreign_key: :source_id, optional: true # created only for has_free_shipping?
-
-    validates :adjustable, :order, :label, presence: true
-    validates :amount, numericality: true
-
-    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
-
-    # FIXME: we should check if we also need to fire this action after update
-    after_create :update_adjustable_adjustment_total
-    after_destroy :update_adjustable_adjustment_total
-
-    class_attribute :competing_promos_source_types
-
-    self.competing_promos_source_types = ['Spree::PromotionAction']
-
-    scope :not_finalized, -> { where(state: 'open') }
-    scope :finalized, -> { where(state: 'closed') }
-    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 :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 :nonzero, -> { where("#{quoted_table_name}.amount != 0") }
-    scope :non_zero, -> { where.not(amount: [nil, 0]) }
-    scope :promotion, -> { where(source_type: 'Spree::PromotionAction') }
-    scope :return_authorization, -> { where(source_type: 'Spree::ReturnAuthorization') }
-    scope :is_included, -> { where(included: true) }
-    scope :additional, -> { where(included: false) }
-    scope :competing_promos, -> { where(source_type: competing_promos_source_types) }
-    scope :for_complete_order, -> { joins(:order).merge(Spree::Order.complete) }
-    scope :for_incomplete_order, -> { joins(:order).merge(Spree::Order.incomplete) }
-
-    extend DisplayMoney
-    money_methods :amount
-
-    def amount=(amount)
-      self[:amount] = Spree::LocalizedNumber.parse(amount)
-    end
-
-    def currency
-      adjustable ? adjustable.currency : order.currency
-    end
-
-    def promotion?
-      source_type == 'Spree::PromotionAction'
-    end
-
-    def tax?
-      source_type == 'Spree::TaxRate'
-    end
-
-    def additional?
-      !included?
-    end
-
-    # 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.
-    def update!(target = adjustable)
-      src = source
-      return amount if closed? || src.blank?
-
-      new_amount = src.compute_amount(target)
-      new_eligible = promotion? ? src.promotion.eligible?(target) : eligible
-
-      changed_attributes = {}
-      changed_attributes[:amount] = new_amount if new_amount != amount
-      changed_attributes[:eligible] = new_eligible if new_eligible != eligible
-
-      if changed_attributes.any?
-        changed_attributes[:updated_at] = Time.current
-        update_columns(changed_attributes)
-      end
-
-      new_amount
-    end
-
-    private
-
-    def update_adjustable_adjustment_total
-      # Cause adjustable's total to be recalculated
-      Adjustable::AdjustmentsUpdater.update(adjustable)
-    end
-  end
-end

data/app/models/spree/asset/support/active_storage.rb

@@ -1,26 +0,0 @@
-module Spree
-  class Asset < Spree.base_class
-    module Support
-      module ActiveStorage
-        extend ActiveSupport::Concern
-
-        included do
-          def url(style)
-            return placeholder(style) unless attachment.attached?
-
-            attachment.variant(resize_to_limit: dimensions_for_style(style))
-          end
-
-          def placeholder(style)
-            "noimage/#{style}.png"
-          end
-
-          def dimensions_for_style(style)
-            dimensions = self.class.styles.with_indifferent_access[style] || self.class.styles.with_indifferent_access[default_style]
-            dimensions.split('x').map(&:to_i)
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,87 +0,0 @@
-require_dependency 'spree/calculator'
-
-module Spree
-  class Calculator::DefaultTax < Calculator
-    include Spree::VatPriceCalculation
-    def self.description
-      Spree.t(:default_tax)
-    end
-
-    # 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.
-    #
-    # Both tax modes are computed from the item's live taxable basis, which
-    # follows every discount: item-level promotions and the item's share of
-    # whole-order promotions (see LineItem#taxable_basis). Included
-    # (VAT-style) tax intentionally does not read the stored pre_tax_amount
-    # column — that column is only refreshed by Spree::TaxRate.adjust on
-    # checkout transitions, so it goes stale the moment a promotion is
-    # applied or removed.
-    def compute_shipment_or_line_item(item)
-      basis = item.taxable_basis
-
-      if rate.included_in_price
-        deduced_total_by_rate(net_basis(item, basis), rate)
-      else
-        round_to_two_places(basis * rate.amount)
-      end
-    end
-
-    alias compute_shipment compute_shipment_or_line_item
-    alias 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)
-        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
-
-    private
-
-    def rate
-      calculable
-    end
-
-    def deduced_total_by_rate(pre_tax_amount, rate)
-      round_to_two_places(pre_tax_amount * rate.amount)
-    end
-
-    # Backs all included-in-price rates out of the gross basis, mirroring
-    # Spree::TaxRate.store_pre_tax_amount (several rates can share a tax
-    # category, e.g. MOSS VAT). Falls back to this rate's amount when no
-    # rate matches the item, e.g. in bare setups without matching zones.
-    def net_basis(item, basis)
-      included = included_rates_amount(item)
-      included = rate.amount if included.zero?
-
-      basis / (1 + included)
-    end
-
-    # Memoized per tax category: tax rate and zone rows are configuration,
-    # invariant within a recalculation pass.
-    def included_rates_amount(item)
-      @included_rates_amount ||= {}
-      @included_rates_amount[item.tax_category_id] ||=
-        Spree::TaxRate.included_tax_amount_for(tax_zone: rate.zone, tax_category: item.tax_category)
-    end
-  end
-end

data/app/models/spree/calculator/returns/default_refund_amount.rb

@@ -1,40 +0,0 @@
-require_dependency 'spree/returns_calculator'
-
-module Spree
-  module Calculator::Returns
-    class DefaultRefundAmount < ReturnsCalculator
-      attr_reader :inventory_unit
-
-      def self.description
-        Spree.t(:default_refund_amount)
-      end
-
-      def compute(return_item)
-        return 0.0.to_d if return_item.exchange_requested?
-
-        @inventory_unit = return_item.inventory_unit
-        weighted_order_adjustment_amount(return_item) + weighted_line_item_pre_tax_amount(return_item)
-      end
-
-      private
-
-      def weighted_order_adjustment_amount(return_item)
-        inventory_unit.order.adjustments.eligible.non_tax.sum(:amount) * percentage_of_order_total(return_item)
-      end
-
-      def percentage_of_order_total(return_item)
-        return 0.0 if inventory_unit.order.pre_tax_item_amount.zero?
-
-        weighted_line_item_pre_tax_amount(return_item) / inventory_unit.order.pre_tax_item_amount
-      end
-
-      def weighted_line_item_pre_tax_amount(return_item)
-        inventory_unit.line_item.pre_tax_amount * percentage_of_line_item(return_item)
-      end
-
-      def percentage_of_line_item(return_item)
-        return_item.return_quantity / BigDecimal(inventory_unit.line_item.quantity)
-      end
-    end
-  end
-end

data/app/models/spree/customer_return.rb

@@ -1,94 +0,0 @@
-module Spree
-  class CustomerReturn < Spree.base_class
-    has_prefix_id :cr
-
-    include Spree::Core::NumberGenerator.new(prefix: 'CR', length: 9)
-    include Spree::NumberIdentifier
-    include Spree::Metafields
-    include Spree::Metadata
-
-    publishes_lifecycle_events
-
-    belongs_to :stock_location
-    belongs_to :store, class_name: 'Spree::Store', inverse_of: :customer_returns
-
-    has_many :reimbursements, inverse_of: :customer_return
-    has_many :return_items, inverse_of: :customer_return
-    has_many :return_authorizations, through: :return_items
-
-    after_create :process_return!
-
-    validates :store, presence: true
-    validates :return_items, :stock_location, presence: true
-    validate :must_have_return_authorization, on: :create
-    validate :return_items_belong_to_same_order
-
-    accepts_nested_attributes_for :return_items
-
-    extend DisplayMoney
-    money_methods :pre_tax_total
-
-    self.whitelisted_ransackable_attributes = ['number']
-
-    delegate :id, to: :order, prefix: true, allow_nil: true
-
-    def completely_decided?
-      !return_items.undecided.exists?
-    end
-
-    def fully_reimbursed?
-      completely_decided? && return_items.accepted.includes(:reimbursement).all? { |return_item| return_item.reimbursement.try(:reimbursed?) }
-    end
-
-    def currency
-      order&.currency
-    end
-
-    # Temporarily tie a customer_return to one order
-    def order
-      return nil if return_items.blank?
-      return nil if return_items.first.inventory_unit.blank?
-
-      return_items.first.inventory_unit.order
-    end
-
-    def pre_tax_total
-      return_items.sum(:pre_tax_amount)
-    end
-
-    def can_create_reimbursement?
-      !fully_reimbursed? && completely_decided? && no_pending_reimbursements?
-    end
-
-    def no_pending_reimbursements?
-      if association(:reimbursements).loaded?
-        reimbursements.select(&:pending?).empty?
-      else
-        reimbursements.where(reimbursement_status: :pending).none?
-      end
-    end
-
-    private
-
-    def inventory_units
-      return_items.flat_map(&:inventory_unit)
-    end
-
-    def must_have_return_authorization
-      if (item = return_items.find { |ri| ri.return_authorization.blank? })
-        errors.add(:base, Spree.t(:missing_return_authorization, item_name: item.inventory_unit.variant.name))
-      end
-    end
-
-    def process_return!
-      return_items.each(&:receive!)
-      order.return! if order.all_inventory_units_returned?
-    end
-
-    def return_items_belong_to_same_order
-      if return_items.any? { |return_item| return_item.inventory_unit.order_id != order_id }
-        errors.add(:base, Spree.t(:return_items_cannot_be_associated_with_multiple_orders))
-      end
-    end
-  end
-end

data/app/models/spree/image/configuration/active_storage.rb

@@ -1,11 +0,0 @@
-# @deprecated This module is now a no-op. All logic has been moved to Spree::Asset.
-# Will be removed in Spree 6.0.
-module Spree
-  class Image < Asset
-    module Configuration
-      module ActiveStorage
-        extend ActiveSupport::Concern
-      end
-    end
-  end
-end

data/app/models/spree/image.rb

@@ -1,6 +0,0 @@
-# Backward compatibility — all logic now lives in Spree::Asset.
-# This class will be removed in Spree 6.0.
-module Spree
-  class Image < Asset
-  end
-end

data/app/models/spree/legacy_admin_user.rb

@@ -1,31 +0,0 @@
-# Default implementation of AdminUser for staff/admin accounts.
-# This class is separate from LegacyUser to support distinct customer vs staff models.
-require 'bcrypt'
-
-module Spree
-  class LegacyAdminUser < Spree.base_class
-    include Spree::AdminUserMethods
-
-    self.table_name = 'spree_admin_users'
-
-    attr_accessor :password, :password_confirmation
-
-    validates :email, presence: true, uniqueness: { case_sensitive: false }
-
-    before_save :encrypt_password, if: :password
-
-    # Simple password validation for testing purposes
-    # In production, Spree.admin_user_class should be overridden with a proper auth solution (e.g., Devise)
-    def valid_password?(check_password)
-      return false if encrypted_password.blank?
-
-      BCrypt::Password.new(encrypted_password) == check_password
-    end
-
-    private
-
-    def encrypt_password
-      self.encrypted_password = BCrypt::Password.create(password)
-    end
-  end
-end

data/app/models/spree/legacy_user.rb

@@ -1,33 +0,0 @@
-# Default implementation of User.
-require 'bcrypt'
-
-module Spree
-  class LegacyUser < Spree.base_class
-    include Spree::UserAddress
-    include Spree::UserPaymentSource
-    include Spree::UserMethods
-
-    self.table_name = 'spree_users'
-
-    attr_accessor :password, :password_confirmation
-
-    validates :email, presence: true, uniqueness: { case_sensitive: false }
-    validates :password, confirmation: true, if: :password
-
-    before_save :encrypt_password, if: :password
-
-    # Simple password validation for testing purposes
-    # In production, Spree.user_class should be overridden with a proper auth solution (e.g., Devise)
-    def valid_password?(check_password)
-      return false if encrypted_password.blank?
-
-      BCrypt::Password.new(encrypted_password) == check_password
-    end
-
-    private
-
-    def encrypt_password
-      self.encrypted_password = BCrypt::Password.create(password)
-    end
-  end
-end

data/app/models/spree/log_entry.rb

@@ -1,30 +0,0 @@
-module Spree
-  class LogEntry < Spree.base_class
-    has_prefix_id :log
-
-    if defined?(Spree::Security::LogEntries)
-      include Spree::Security::LogEntries
-    end
-
-    belongs_to :source, polymorphic: true
-
-    # Fix for #1767
-    # If a payment fails, we want to make sure we keep the record of it failing
-    after_rollback :save_anyway, if: proc { !Rails.env.test? }
-
-    def save_anyway
-      Spree::LogEntry.create!(source: source, details: details)
-    end
-
-    def parsed_details
-      @details ||= YAML.safe_load(
-        details,
-        permitted_classes: [
-          Spree::PaymentResponse,
-          ActiveSupport::HashWithIndifferentAccess,
-          (ActiveMerchant::Billing::Response if defined?(ActiveMerchant::Billing::Response))
-        ].compact
-      )
-    end
-  end
-end

data/app/models/spree/metafields/boolean.rb

@@ -1,15 +0,0 @@
-module Spree
-  module Metafields
-    class Boolean < Spree::Metafield
-      normalizes :value, with: ->(value) { value.to_b.to_s }
-
-      def csv_value
-        value.to_b ? Spree.t(:say_yes) : Spree.t(:say_no)
-      end
-
-      def serialize_value
-        value.to_b
-      end
-    end
-  end
-end

data/app/models/spree/metafields/json.rb

@@ -1,37 +0,0 @@
-module Spree
-  module Metafields
-    class Json < Spree::Metafield
-      validate :value_must_be_valid_json
-
-      # Accept either a JSON-serialized String (from CSV / Admin UI text
-      # input) or a raw Hash / Array (from API callers that ship parsed
-      # objects). Non-String inputs get JSON-serialized so the underlying
-      # text column always holds canonical JSON.
-      #
-      # @param raw [String, Hash, Array, nil]
-      def value=(raw)
-        super(raw.is_a?(Hash) || raw.is_a?(Array) ? raw.to_json : raw)
-      end
-
-      def serialize_value
-        JSON.parse(value)
-      rescue JSON::ParserError
-        value
-      end
-
-      def csv_value
-        value.to_s
-      end
-
-      private
-
-      def value_must_be_valid_json
-        return if value.blank?
-
-        JSON.parse(value)
-      rescue JSON::ParserError => e
-        errors.add(:value, "must be valid JSON: #{e.message}")
-      end
-    end
-  end
-end

data/app/models/spree/metafields/long_text.rb

@@ -1,7 +0,0 @@
-module Spree
-  module Metafields
-    class LongText < Spree::Metafield
-      normalizes :value, with: ->(value) { value.to_s.strip }
-    end
-  end
-end

data/app/models/spree/metafields/number.rb

@@ -1,15 +0,0 @@
-module Spree
-  module Metafields
-    class Number < Spree::Metafield
-      validates :value, numericality: true
-
-      def serialize_value
-        value.to_d
-      end
-
-      def csv_value
-        value.to_d.to_s
-      end
-    end
-  end
-end

data/app/models/spree/metafields/rich_text.rb

@@ -1,18 +0,0 @@
-module Spree
-  module Metafields
-    class RichText < Spree::Metafield
-      # Avoid collision with the `value` column used by other metafield types
-      self.ignored_columns = %w[value]
-
-      has_rich_text :value
-
-      def serialize_value
-        value&.body&.to_s
-      end
-
-      def csv_value
-        value&.body&.to_plain_text || ''
-      end
-    end
-  end
-end

data/app/models/spree/metafields/short_text.rb

@@ -1,7 +0,0 @@
-module Spree
-  module Metafields
-    class ShortText < Spree::Metafield
-      normalizes :value, with: ->(value) { value.to_s.strip }
-    end
-  end
-end

data/app/models/spree/option_type_prototype.rb

@@ -1,9 +0,0 @@
-module Spree
-  class OptionTypePrototype < Spree.base_class
-    belongs_to :option_type, class_name: 'Spree::OptionType'
-    belongs_to :prototype, class_name: 'Spree::Prototype'
-
-    validates :prototype, :option_type, presence: true
-    validates :prototype_id, uniqueness: { scope: :option_type_id }
-  end
-end