solidus_core 2.9.6 → 2.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 482b41309b1c87feff6b32679da923ed2f6077ca241fd0d1bb358647f4261bb1
-  data.tar.gz: db5b3124cc3b7c29b916e037d0e1f16ba378aaa386282f59bb873225cee6c33d
+  metadata.gz: 67f52a65e6e81c1ce08998d4e78697917ec11a458b2186407c8787e5f720f438
+  data.tar.gz: 744a81976801433d6db59d9b91838b5f726a5760248d5d35bf5479d10b6548c8
 SHA512:
-  metadata.gz: bc163558062f4da4c642a1946bfa1fc1d6dfc9a47dddf0fb3f3c3c44c06810e33fe02cbddca9ef007469eb594a19644ce1344d51cc5b04f6b5a039cf57dcc335
-  data.tar.gz: e70cf50bf8049770f9fa7ad1be437969dda338298f5dd62b0a44cf545a38f24a57a7d8ccb4e536c8cae5ec899ecd9e18cf40d177adf664bf104ea5d1990e286a
+  metadata.gz: 656ba324a01abefe949d50477b37f1414176ebc8ae025e6875d61d505fd71255243ef3814cf5c3283a32910c4275c434883e445257be8d3e0c98c42b256858d0
+  data.tar.gz: 4efde61091581ff5c04c56363b070278be880cf797ac5d0c494667842486c6896b20c5feb5342e565e891e7dd2b8f3c52c350956258210d6b074cb8664452099

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

@@ -51,12 +51,41 @@ Spree.ajax = function(url, options) {
   return $.ajax(url, options);
 };
 
-Spree.routes = {
+/**
+ * @deprecated Spree.routes will be removed in a future release. Please use Spree.pathFor instead.
+ * See: https://github.com/solidusio/solidus/issues/3405
+ */
+Spree.routesDeprecationProxy = {
+  get: function(obj, prop) {
+    <% if Rails.env != "production" %>
+      console.log("Spree.routes is deprecated, please use pathFor instead. See: https://github.com/solidusio/solidus/issues/3405");
+    <% end %>
+
+    return obj[prop]
+  },
+
+  set: function(obj, prop, value) {
+    <% if Rails.env != "production" %>
+      console.log("Spree.routes is deprecated, please use pathFor instead. See: https://github.com/solidusio/solidus/issues/3405");
+    <% end %>
+
+    obj[prop] = value
+    return value;
+  }
+};
+
+var frontend_routes = {
   states_search: Spree.pathFor('api/states'),
   apply_coupon_code: function(order_id) {
     return Spree.pathFor("api/orders/" + order_id + "/coupon_codes");
   }
-};
+}
+
+if(typeof Proxy == "function") {
+  Spree.routes = new Proxy(frontend_routes, Spree.routesDeprecationProxy);
+} else {
+  Spree.routes = frontend_routes
+}
 
 Spree.getJSON = function(url, data, success) {
   if (typeof data === 'function') {

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/base_helper.rb

@@ -79,16 +79,16 @@ module Spree
 
       crumbs << [t('spree.products'), products_path]
       if taxon
-        crumbs += taxon.ancestors.collect { |a| [a.name, spree.nested_taxons_path(a.permalink)] } unless taxon.ancestors.empty?
+        crumbs += taxon.ancestors.collect { |ancestor| [ancestor.name, spree.nested_taxons_path(ancestor.permalink)] } unless taxon.ancestors.empty?
         crumbs << [taxon.name, spree.nested_taxons_path(taxon.permalink)]
       end
 
       separator = raw(separator)
 
-      items = crumbs.each_with_index.collect do |crumb, i|
+      items = crumbs.each_with_index.collect do |crumb, index|
         content_tag(:li, itemprop: 'itemListElement', itemscope: '', itemtype: 'https://schema.org/ListItem') do
           link_to(crumb.last, itemprop: 'item') do
-            content_tag(:span, crumb.first, itemprop: 'name') + tag('meta', { itemprop: 'position', content: (i + 1).to_s }, false, false)
+            content_tag(:span, crumb.first, itemprop: 'name') + tag('meta', { itemprop: 'position', content: (index + 1).to_s }, false, false)
           end + (crumb == crumbs.last ? '' : separator)
         end
       end
@@ -122,7 +122,7 @@ module Spree
       countries.collect do |country|
         country.name = country_names.fetch(country.iso, country.name)
         country
-      end.sort_by { |c| c.name.parameterize }
+      end.sort_by { |country| country.name.parameterize }
     end
 
     def seo_url(taxon)

data/app/helpers/spree/products_helper.rb

@@ -36,7 +36,8 @@ module Spree
     def variant_full_price(variant)
       return if variant.product.variants
                   .with_prices(current_pricing_options)
-                  .all? { |v| v.price_same_as_master?(current_pricing_options) }
+                  .all? { |variant_with_prices| variant_with_prices.price_same_as_master?(current_pricing_options) }
+
       variant.price_for(current_pricing_options).to_html
     end
 

data/app/jobs/spree/promotion_code_batch_job.rb

@@ -14,13 +14,13 @@ module Spree
           .promotion_code_batch_finished(promotion_code_batch)
           .deliver_now
       end
-    rescue StandardError => e
+    rescue StandardError => error
       if promotion_code_batch.email?
         Spree::Config.promotion_code_batch_mailer_class
           .promotion_code_batch_errored(promotion_code_batch)
           .deliver_now
       end
-      raise e
+      raise error
     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/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.rb

@@ -0,0 +1,116 @@
+# 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)
+    end
+
+    def destroy_attachment(_name)
+      attachment.destroy
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+# 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
+
+      DEFAULT_SIZE = '100%'
+
+      def initialize(attachment, styles: {})
+        @attachment = attachment
+        @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&.to_sym)
+        @attachment.variant(
+          resize: size,
+          strip: true,
+          'auto-orient': true,
+          colorspace: 'sRGB',
+        ).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 style_to_size(style)
+        @styles.fetch(style) { DEFAULT_SIZE }
+      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/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,18 @@
+# frozen_string_literal: true
+
+require 'discard'
+
+module Spree
+  module SoftDeletable
+    extend ActiveSupport::Concern
+
+    included do
+      acts_as_paranoid
+      include Spree::ParanoiaDeprecations::InstanceMethods
+      extend Spree::ParanoiaDeprecations::ClassMethods
+
+      include Discard::Model
+      self.discard_column = :deleted_at
+    end
+  end
+end

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

@@ -5,62 +5,92 @@ 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'
+      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)
+    def default_address
+      Spree::Deprecation.warn "#default_address is deprecated. Please start using #ship_address."
+      ship_address
     end
 
-    def bill_address_attributes=(attributes)
-      self.bill_address = Spree::Address.immutable_merge(bill_address, attributes)
+    def default_user_address
+      Spree::Deprecation.warn "#default_user_address is deprecated. Please start using #default_user_ship_address."
+      default_user_ship_address
     end
 
     def default_address=(address)
-      save_in_address_book(address.attributes, true) if address
+      Spree::Deprecation.warn(
+        "#default_address= does not take Spree::Config.automatic_default_address into account and is deprecated. " \
+        "Please use #ship_address=."
+      )
+
+      self.ship_address = address 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 = Spree::Address.immutable_merge(default_address, attributes)
-    end
+      Spree::Deprecation.warn "#default_address_attributes= is deprecated. Please use #ship_address_attributes=."
 
-    alias_method :ship_address_attributes=, :default_address_attributes=
+      self.default_address = Spree::Address.immutable_merge(ship_address, attributes)
+    end
 
     # 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
+      if address
+        save_in_address_book(address.attributes,
+                             Spree::Config.automatic_default_address)
+      end
+    end
+
+    def ship_address_attributes=(attributes)
+      self.ship_address = Spree::Address.immutable_merge(ship_address, attributes)
+    end
+
+    def bill_address=(address)
+      if address
+        save_in_address_book(address.attributes,
+                             Spree::Config.automatic_default_address,
+                             :billing)
+      end
+    end
+
+    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 +103,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 +123,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 +138,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,21 +148,37 @@ 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)
+      Spree::Deprecation.warn(
+        "#mark_default_address is deprecated and it sets the ship_address only. " \
+        "Please use #mark_default_ship_address."
+      )
+
+      mark_default_ship_address(address)
+    end
+
+    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
-        user_address.update_attributes(archived: true, default: false)
+        remove_user_address_reference(address_id)
+        user_address.update(archived: true, default: false)
       else
         false
       end
@@ -145,5 +193,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