solidus_core 2.10.5 → 3.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 90b8c15a6d8cd5afe92bda035e5030a7fdcb10dee8333e8e29ed856e6e984d8d
-  data.tar.gz: 4400ce56c58133a1fe8564a2577b771e568a985227ab4e6cb7ebff79f6c83f04
+  metadata.gz: 7f1c5b9cf50bbdf85b17b2efb5fe3812a2882e28133794a7ae898402345bf265
+  data.tar.gz: 5eda0c67dd0eecd516656449aa2fc9b627bddb5586ed71085337806533b0b330
 SHA512:
-  metadata.gz: 9925579a8e26a3dae259ca7b646b79e66e13b4dc9ea183c1c836b6382bd277a255cf87f879fee30fa5cc6c24ddb76be8680144b88102a2623015f2383cced868
-  data.tar.gz: a281e5378b803c0ef7393eea0cf8a6a62192c5180a90e2d4ca540f7fb0c6b39027e66c1fc3868628a582e758f9a5c45261c8995f90e52e34b4cb1392383840d6
+  metadata.gz: 6362257bfa6688911f046e5c6ae0df2061622866441c7d81555ad1ee842da94d273c079a0a289e9691c130e17632a4765f314cc1ae073cd7f5cc364a181939e4
+  data.tar.gz: 8c18d66c2fe84abecf9111a972ab2127d8406d53b510617518d518abba342847246e2f8d9226bb9b57ac45a070b63da1f55fc385d654a99db17f9e04e17be67c

data/app/assets/javascripts/spree.js.erb

@@ -22,21 +22,6 @@ Spree.pathFor = function(path) {
   return locationOrigin + Spree.mountedAt() + path;
 };
 
-Spree.url = function(uri, query) {
-  if (console && console.warn) {
-    console.warn('Spree.url is deprecated, and will be removed from a future Solidus version.');
-  }
-  if (uri.path === undefined) {
-    uri = new Uri(uri);
-  }
-  if (query) {
-    $.each(query, function(key, value) {
-      return uri.addQueryParam(key, value);
-    });
-  }
-  return uri;
-};
-
 Spree.ajax = function(url, options) {
   if (typeof url === "object") {
     options = url;
@@ -51,13 +36,6 @@ Spree.ajax = function(url, options) {
   return $.ajax(url, options);
 };
 
-Spree.routes = {
-  states_search: Spree.pathFor('api/states'),
-  apply_coupon_code: function(order_id) {
-    return Spree.pathFor("api/orders/" + order_id + "/coupon_codes");
-  }
-};
-
 Spree.getJSON = function(url, data, success) {
   if (typeof data === 'function') {
     success = data;

data/app/controllers/spree/base_controller.rb

@@ -4,6 +4,7 @@ require 'cancan'
 require_dependency 'spree/core/controller_helpers/strong_parameters'
 
 class Spree::BaseController < ApplicationController
+  include Spree::Core::ControllerHelpers::CurrentHost
   include Spree::Core::ControllerHelpers::Auth
   include Spree::Core::ControllerHelpers::Common
   include Spree::Core::ControllerHelpers::PaymentParameters

data/app/helpers/spree/store_helper.rb

@@ -8,16 +8,5 @@ module Spree
     def store_menu?
       %w{thank_you}.exclude? params[:action]
     end
-
-    def cache_key_for_taxons
-      Spree::Deprecation.warn <<-WARN.strip_heredoc
-        cache_key_for_taxons is deprecated. Rails >= 5 has built-in support for collection cache keys.
-        Instead in your view use:
-        cache [I18n.locale, @taxons] do
-      WARN
-      max_updated_at = @taxons.maximum(:updated_at).to_i
-      parts = [@taxon.try(:id), max_updated_at].compact.join("-")
-      "#{I18n.locale}/taxons/#{parts}"
-    end
   end
 end

data/app/mailers/spree/base_mailer.rb

@@ -6,6 +6,10 @@ module Spree
       store.mail_from_address
     end
 
+    def bcc_address(store)
+      store.bcc_email
+    end
+
     def money(amount, currency = Spree::Config[:currency])
       Spree::Money.new(amount, currency: currency).to_s
     end

data/app/mailers/spree/carton_mailer.rb

@@ -11,11 +11,7 @@ module Spree
     # @option options resend [Boolean] indicates whether the email is a 'resend' (e.g.
     #   triggered by the admin "resend" button)
     # @return [Mail::Message]
-    #
-    # Note: The signature of this method has changed. The new (non-deprecated)
-    # signature is:
-    #   def shipped_email(carton:, order:, resend: false)
-    def shipped_email(options, _deprecated_options = {})
+    def shipped_email(options)
       @order = options.fetch(:order)
       @carton = options.fetch(:carton)
       @manifest = @carton.manifest_for_order(@order)

data/app/mailers/spree/order_mailer.rb

@@ -7,7 +7,7 @@ module Spree
       @store = @order.store
       subject = build_subject(t('.subject'), resend)
 
-      mail(to: @order.email, from: from_address(@store), subject: subject)
+      mail(to: @order.email, bcc: bcc_address(@store), from: from_address(@store), subject: subject)
     end
 
     def cancel_email(order, resend = false)

data/app/models/concerns/spree/active_storage_adapter/attachment.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'mini_magick'
+
+module Spree
+  module ActiveStorageAdapter
+    # Decorares AtiveStorage attachment to add methods exptected by Solidus'
+    # Paperclip-oriented attachment support.
+    class Attachment
+      delegate_missing_to :@attachment
+
+      def initialize(attachment, styles: {})
+        @attachment = attachment
+        @styles = normalize_styles(styles)
+      end
+
+      def exists?
+        attached?
+      end
+
+      def filename
+        blob&.filename.to_s
+      end
+
+      def url(style = nil)
+        variant(style)&.url
+      end
+
+      def variant(style = nil)
+        size = style_to_size(style)
+        @attachment.variant(
+          resize_to_limit: size,
+          saver: {
+            strip: true
+          }
+        ).processed
+      end
+
+      def height
+        metadata[:height]
+      end
+
+      def width
+        metadata[:width]
+      end
+
+      def destroy
+        return false unless attached?
+
+        purge
+        true
+      end
+
+      private
+
+      def metadata
+        analyze unless analyzed?
+
+        @attachment.metadata
+      end
+
+      def normalize_styles(styles)
+        styles.transform_values { |v| v.split('x').map(&:to_i) }
+      end
+
+      def style_to_size(style)
+        @styles.fetch(style&.to_sym) { [width, height] }
+      end
+    end
+  end
+end

data/app/models/concerns/spree/active_storage_adapter/normalization.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Spree
+  module ActiveStorageAdapter
+    # Contains normalization methods to make objects compliant with
+    # ActiveStorage API.
+    module Normalization
+      # Normalizes an attachable
+      def normalize_attachable(attachable)
+        case attachable
+        when ActiveStorage::Blob, ActionDispatch::Http::UploadedFile,
+          Rack::Test::UploadedFile, Hash, String
+          attachable
+        when Attachment, ActiveStorage::Attached
+          attachable_blob(attachable)
+        else # assume it's an IO
+          attachable_io(attachable)
+        end
+      end
+
+      private
+
+      def attachable_blob(attachable)
+        attachable.blob
+      end
+
+      def attachable_io(attachable)
+        filename = if attachable.respond_to?(:to_path)
+                     attachable.to_path
+                   else
+                     SecureRandom.uuid
+                   end
+        attachable.rewind
+
+        { io: attachable, filename: filename }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Spree
+  # Adapts ActiveStorage interface to make it compliant with Solidus'
+  # Paperclip-oriented attachment support.
+  module ActiveStorageAdapter
+    extend ActiveSupport::Concern
+    include Spree::ActiveStorageAdapter::Normalization
+
+    included do
+      next if Rails.gem_version >= Gem::Version.new('6.1.0.alpha')
+
+      abort <<~MESSAGE
+        Configuration Error: Solidus ActiveStorage attachment adpater requires Rails >= 6.1.0.
+
+        Spree::Config.image_attachment_module preference is set to #{Spree::Config.image_attachment_module}
+        Spree::Config.taxon_attachment_module preference is set to #{Spree::Config.taxon_attachment_module}
+        Rails version is #{Rails.gem_version}
+
+        To solve the problem you can upgrade to a Rails version greater than or equal to 6.1.0
+        or use legacy Paperclip attachment adapter by editing `config/initialiers/spree/rb`:
+        config.image_attachment_module = 'Spree::Image::PaperclipAttachment'
+        config.taxon_attachment_module = 'Spree::Taxon::PaperclipAttachment'
+      MESSAGE
+    end
+
+    class_methods do
+      attr_reader :attachment_name
+      attr_reader :attachment_definition
+
+      # Specifies the relation between a single attachment and the model
+      def has_attachment(name, definition)
+        @attachment_name = name.to_sym
+        @attachment_definition = definition
+
+        has_one_attached attachment_name
+
+        override_reader
+        override_writer
+        define_image_validation
+        define_presence_reader
+      end
+
+      def attachment_definitions
+        { attachment_name => attachment_definition }
+      end
+
+      private
+
+      def override_reader
+        method_name = attachment_name
+        override = Module.new do
+          define_method method_name do |*args|
+            attachment = Attachment.new(super(), styles: styles)
+            if args.empty?
+              attachment
+            else
+              style = args.first || default_style
+              attachment.url(style)
+            end
+          end
+        end
+        prepend override
+
+        alias_method :attachment, method_name if method_name != :attachment
+      end
+
+      def override_writer
+        method_name = :"#{attachment_name}="
+        override = Module.new do
+          define_method method_name do |attachable|
+            no_other_changes = persisted? && !changed?
+            super(normalize_attachable(attachable))
+            save if no_other_changes
+          end
+        end
+        prepend override
+      end
+
+      def define_image_validation
+        define_method :"#{attachment_name}_is_an_image" do
+          return unless attachment.attached?
+          return if attachment.image?
+
+          errors.add(self.class.attachment_name, 'is not an image')
+        end
+      end
+
+      def define_presence_reader
+        define_method :"#{attachment_name}_present?" do
+          attachment.attached?
+        end
+      end
+    end
+
+    def styles
+      self.class.attachment_definition[:styles]
+    end
+
+    def default_style
+      self.class.attachment_definition[:default_style]
+    end
+
+    def filename
+      attachment.filename
+    end
+
+    def url(style = default_style)
+      attachment.url(style)
+    rescue ActiveStorage::FileNotFoundError
+      "noimage/#{style}.png"
+    end
+
+    def destroy_attachment(_name)
+      attachment.destroy
+    end
+  end
+end

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

@@ -2,21 +2,6 @@
 
 module Spree
   module AdjustmentSource
-    def deals_with_adjustments_for_deleted_source
-      Spree::Deprecation.warn "AdjustmentSource#deals_with_adjustments_for_deleted_source is deprecated. Please use AdjustmentSource#remove_adjustments_from_incomplete_orders instead."
-
-      remove_adjustments_from_incomplete_orders
-
-      # The following is deprecated. As source_type without a source_id isn't
-      # much better than a source_id that doesn't exist.  In Solidus itself the
-      # relevant classes use `acts_as_paranoid` so it is useful to keep the
-      # source_id around.
-      adjustments.
-        joins(:order).
-        merge(Spree::Order.complete).
-        update_all(source_id: nil, updated_at: Time.current)
-    end
-
     def remove_adjustments_from_incomplete_orders
       adjustments.
         joins(:order).

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

@@ -10,24 +10,6 @@ module Spree
       validates :calculator, presence: true
     end
 
-    class_methods do
-      def calculators
-        Spree::Deprecation.warn("Calling .calculators is deprecated. Please access through Rails.application.config.spree.calculators")
-
-        spree_calculators.send model_name_without_spree_namespace
-      end
-
-      private
-
-      def model_name_without_spree_namespace
-        to_s.tableize.tr('/', '_').sub('spree_', '')
-      end
-
-      def spree_calculators
-        Spree::Config.environment.calculators
-      end
-    end
-
     def calculator_type
       calculator.class.to_s if calculator
     end

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

@@ -6,7 +6,7 @@ module Spree
 
     included do
       has_one :default_price,
-        -> { with_deleted.currently_valid.with_default_attributes },
+        -> { with_discarded.currently_valid.with_default_attributes },
         class_name: 'Spree::Price',
         inverse_of: :variant,
         dependent: :destroy,

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

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require 'discard'
+
+module Spree
+  module SoftDeletable
+    extend ActiveSupport::Concern
+
+    included do
+      include Discard::Model
+      self.discard_column = :deleted_at
+
+      default_scope { kept }
+    end
+  end
+end

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

@@ -5,62 +5,64 @@ 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 == Spree::Address.new(address_attrs) }
         end
 
-        # @note this method enforces only one default address per user
-        def mark_default(user_address)
-          # the checks of persisted? allow us to build a User and associate Addresses at once
+        def mark_default(user_address, address_type: :shipping)
+          column_for_default = address_type == :shipping ? :default : :default_billing
           ActiveRecord::Base.transaction do
-            (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
+            (self - [user_address]).each do |address| # update_all would be nice, but it bypasses ActiveRecord callbacks
+              if address.persisted?
+                address.update!(column_for_default => false)
+              else
+                address.write_attribute(column_for_default, false)
+              end
+            end
+
+            if user_address.persisted?
+              user_address.update!(column_for_default => true, archived: false)
+            else
+              user_address.write_attribute(column_for_default, true)
             end
-            user_address.persisted? ? user_address.update!(default: true, archived: false) : user_address.default = true
           end
         end
       end
 
       has_many :addresses, through: :user_addresses
 
-      # 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', optional: true
+      has_one :default_user_bill_address, ->{ default_billing }, class_name: 'Spree::UserAddress', foreign_key: 'user_id'
+      has_one :bill_address, through: :default_user_bill_address, source: :address
 
-      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
+      has_one :default_user_ship_address, ->{ default_shipping }, class_name: 'Spree::UserAddress', foreign_key: 'user_id'
+      has_one :ship_address, through: :default_user_ship_address, source: :address
     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 bill_address_attributes=(attributes)
-      self.bill_address = Spree::Address.immutable_merge(bill_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)
+      if address
+        save_in_address_book(address.attributes,
+                             Spree::Config.automatic_default_address)
+      end
     end
 
-    def default_address=(address)
-      save_in_address_book(address.attributes, true) if address
+    def ship_address_attributes=(attributes)
+      self.ship_address = Spree::Address.immutable_merge(ship_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 = Spree::Address.immutable_merge(default_address, attributes)
+    def bill_address=(address)
+      if address
+        save_in_address_book(address.attributes,
+                             Spree::Config.automatic_default_address,
+                             :billing)
+      end
     end
 
-    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
+    def bill_address_attributes=(attributes)
+      self.bill_address = Spree::Address.immutable_merge(bill_address, attributes)
     end
 
     # saves order.ship_address and order.bill_address in address book
@@ -73,15 +75,16 @@ module Spree
           order.ship_address.attributes,
           Spree::Config.automatic_default_address
         )
-        self.ship_address_id = address.id if address && address.persisted?
+        self.ship_address_id = address.id if address&.persisted?
       end
 
       if order.bill_address
         address = save_in_address_book(
           order.bill_address.attributes,
-          order.ship_address.nil? && Spree::Config.automatic_default_address
+          Spree::Config.automatic_default_address,
+          :billing
         )
-        self.bill_address_id = address.id if address && address.persisted?
+        self.bill_address_id = address.id if address&.persisted?
       end
 
       save! # In case the ship_address_id or bill_address_id was set
@@ -92,8 +95,9 @@ module Spree
     # 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?
+    def save_in_address_book(address_attributes, default = false, address_type = :shipping)
+      return nil if address_attributes.blank?
+
       address_attributes = address_attributes.to_h.with_indifferent_access
 
       new_address = Spree::Address.factory(address_attributes)
@@ -106,7 +110,7 @@ module Spree
       end
 
       user_address = prepare_user_address(new_address)
-      user_addresses.mark_default(user_address) if default || first_one
+      user_addresses.mark_default(user_address, address_type: address_type) if default || first_one
 
       if persisted?
         user_address.save!
@@ -116,20 +120,27 @@ module Spree
         # user_addresses need to be reset to get the new ordering based on any changes
         # {default_,}user_address needs to be reset as its result is likely to have changed.
         user_addresses.reset
-        association(:default_user_address).reset
-        association(:default_address).reset
+        association(:default_user_ship_address).reset
+        association(:ship_address).reset
+        association(:default_user_bill_address).reset
+        association(:bill_address).reset
       end
 
       user_address.address
     end
 
-    def mark_default_address(address)
+    def mark_default_ship_address(address)
       user_addresses.mark_default(user_addresses.find_by(address: address))
     end
 
+    def mark_default_bill_address(address)
+      user_addresses.mark_default(user_addresses.find_by(address: address), address_type: :billing)
+    end
+
     def remove_from_address_book(address_id)
       user_address = user_addresses.find_by(address_id: address_id)
       if user_address
+        remove_user_address_reference(address_id)
         user_address.update(archived: true, default: false)
       else
         false
@@ -145,5 +156,11 @@ module Spree
       user_address.archived = false
       user_address
     end
+
+    def remove_user_address_reference(address_id)
+      self.bill_address_id = bill_address_id == address_id.to_i ? nil : bill_address_id
+      self.ship_address_id = ship_address_id == address_id.to_i ? nil : ship_address_id
+      save if changed?
+    end
   end
 end

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

@@ -7,7 +7,6 @@ module Spree
     include Spree::UserApiAuthentication
     include Spree::UserReporting
     include Spree::UserAddressBook
-    include Spree::UserPaymentSource
 
     included do
       extend Spree::DisplayMoney
@@ -19,27 +18,26 @@ module Spree
       has_many :stock_locations, through: :user_stock_locations
 
       has_many :spree_orders, foreign_key: "user_id", class_name: "Spree::Order"
-      has_many :orders, foreign_key: "user_id", class_name: "Spree::Order", dependent: :restrict_with_exception
+      has_many :orders, foreign_key: "user_id", class_name: "Spree::Order"
 
       has_many :store_credits, -> { includes(:credit_type) }, foreign_key: "user_id", class_name: "Spree::StoreCredit"
       has_many :store_credit_events, through: :store_credits
 
-      money_methods :total_available_store_credit
-      deprecate display_total_available_store_credit: :display_available_store_credit_total, deprecator: Spree::Deprecation
-
       has_many :credit_cards, class_name: "Spree::CreditCard", foreign_key: :user_id
       has_many :wallet_payment_sources, foreign_key: 'user_id', class_name: 'Spree::WalletPaymentSource', inverse_of: :user
 
       after_create :auto_generate_spree_api_key
+      before_destroy :check_for_deletion
 
       include Spree::RansackableAttributes unless included_modules.include?(Spree::RansackableAttributes)
 
+      ransack_alias :name, :addresses_name
       self.whitelisted_ransackable_associations = %w[addresses spree_roles]
-      self.whitelisted_ransackable_attributes = %w[id email created_at]
+      self.whitelisted_ransackable_attributes = %w[name id email created_at]
     end
 
     def wallet
-      Spree::Wallet.new(self)
+      @wallet ||= Spree::Wallet.new(self)
     end
 
     # has_spree_role? simply needs to return true or false whether a user has a role or not.
@@ -67,11 +65,6 @@ module Spree
       last_order unless last_order.try!(:completed?)
     end
 
-    def total_available_store_credit
-      store_credits.reload.to_a.sum(&:amount_remaining)
-    end
-    deprecate total_available_store_credit: :available_store_credit_total, deprecator: Spree::Deprecation
-
     def available_store_credit_total(currency:)
       store_credits.to_a.
         select { |credit| credit.currency == currency }.
@@ -84,5 +77,23 @@ module Spree
         currency: currency,
       )
     end
+
+    # Restrict to delete users with existing orders
+    #
+    # Override this in your user model class to add another logic.
+    #
+    # Ie. to allow to delete users with incomplete orders add:
+    #
+    #   orders.complete.none?
+    #
+    def can_be_deleted?
+      orders.none?
+    end
+
+    private
+
+    def check_for_deletion
+      raise ActiveRecord::DeleteRestrictionError unless can_be_deleted?
+    end
   end
 end