goca-spree-core 3.1.14.rails.5.0 → 3.1.14.rails.5.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: aba6863b91a645fcee9334b81d398c7137988e17
-  data.tar.gz: b39ff84eb8f8b960d47fe18095344fc0c909273f
+  metadata.gz: 382329a7b83ef77945ce49e6ad3d27d4e2e53606
+  data.tar.gz: 768251611329f7710e3356481aafb09678b2b898
 SHA512:
-  metadata.gz: dac8ef26d94c18eaede8001b3dbb693a97134e661b86578d9bd3e258bb052e69949a9c39e38a8a95294e710048ce0ba85f2b411e7c10cd914346211c60bad60c
-  data.tar.gz: ef075cdcc94e6c1d9cebeec9b05d4277652d8b00087847bc9ec6081c1d8e8f53dd86dbe7946dcb698f66a008cc6c80101c1d7689743391d5f46afa2295268680
+  metadata.gz: 32dd49043108fb116003998969739efe4933b4e843cf4815ac86858f934288319d24bb63af3d0e5a5f5a0dbb553a7d3d30baab84691dc55014b62dad33828520
+  data.tar.gz: 6f88cc72fb4fb4da976ce8b06f91b0a47a2fe8243002e6d06d9f52dfb36c7c5ed0750958fd93b849d2bdddacfa104fdda4656511ff0fe2c7d996ed3b37bf976d

data/app/helpers/spree/base_helper.rb

@@ -41,7 +41,7 @@ module Spree
       object = instance_variable_get('@'+controller_name.singularize)
       meta = {}
 
-      if object.kind_of? ActiveRecord::Base
+      if object.kind_of? ApplicationRecord
         meta[:keywords] = object.meta_keywords if object[:meta_keywords].present?
         meta[:description] = object.meta_description if object[:meta_description].present?
       end

data/app/models/application_record.rb

@@ -0,0 +1,3 @@
+class ApplicationRecord < ActiveRecord::Base
+  self.abstract_class = true
+end

data/app/models/spree/app_configuration.rb

@@ -58,6 +58,13 @@ module Spree
     preference :tax_using_ship_address, :boolean, default: true
     preference :track_inventory_levels, :boolean, default: true # Determines whether to track on_hand values for variants / products.
 
+    preference :admin_products_per_page, :integer, default: Kaminari.config.default_per_page
+    preference :admin_orders_per_page, :integer, default: Kaminari.config.default_per_page
+    preference :admin_properties_per_page, :integer, default: Kaminari.config.default_per_page
+    preference :admin_promotions_per_page, :integer, default: Kaminari.config.default_per_page
+    preference :admin_customer_returns_per_page, :integer, default: Kaminari.config.default_per_page
+    preference :admin_users_per_page, :integer, default: Kaminari.config.default_per_page
+
     # Store credits configurations
     preference :non_expiring_credit_types, :array, default: []
     preference :credit_to_new_allocation, :boolean, default: false

data/app/models/spree/base.rb

@@ -1,4 +1,4 @@
-class Spree::Base < ActiveRecord::Base
+class Spree::Base < ApplicationRecord
   include Spree::Preferences::Preferable
   serialize :preferences, Hash
 

data/app/models/spree/calculator.rb

@@ -1,7 +1,7 @@
 module Spree
   class Calculator < Spree::Base
     # Conditional check for backwards compatibilty since acts as paranoid was added late https://github.com/spree/spree/issues/5858
-    if ActiveRecord::Base.connected? && connection.data_source_exists?(:spree_calculators) && connection.column_exists?(:spree_calculators, :deleted_at)
+    if connection.data_source_exists?(:spree_calculators) && connection.column_exists?(:spree_calculators, :deleted_at)
       acts_as_paranoid
     end
 

data/app/models/spree/country.rb

@@ -33,7 +33,7 @@ module Spree
     def ensure_not_default
       if id.eql?(Spree::Config[:default_country_id])
         errors.add(:base, Spree.t(:default_country_cannot_be_deleted))
-        false
+        throw(:abort)
       end
     end
   end

data/app/models/spree/credit_card.rb

@@ -1,5 +1,7 @@
 module Spree
   class CreditCard < Spree::Base
+    include ActiveMerchant::Billing::CreditCardMethods
+
     belongs_to :payment_method
     belongs_to :user, class_name: Spree.user_class, foreign_key: 'user_id'
     has_many :payments, as: :source
@@ -15,7 +17,8 @@ module Spree
     attr_reader :number
     attr_accessor :encrypted_data,
                   :imported,
-                  :verification_value
+                  :verification_value,
+                  :manual_entry
 
     with_options if: :require_card_numbers?, on: :create do
       validates :month, :year, numericality: { only_integer: true }
@@ -23,7 +26,7 @@ module Spree
       validates :name, presence: true
     end
 
-    scope :with_payment_profile, -> { where('gateway_customer_profile_id IS NOT NULL') }
+    scope :with_payment_profile, -> { where.not(gateway_customer_profile_id: nil) }
     scope :default, -> { where(default: true) }
 
     # needed for some of the ActiveMerchant gateways (eg. SagePay)

data/app/models/spree/gateway/bogus.rb

@@ -21,43 +21,43 @@ module Spree
       return if payment.source.has_payment_profile?
       # simulate the storage of credit card profile using remote service
       if success = VALID_CCS.include?(payment.source.number)
-        payment.source.update_attributes(:gateway_customer_profile_id => generate_profile_id(success))
+        payment.source.update_attributes(gateway_customer_profile_id: generate_profile_id(success))
       end
     end
 
     def authorize(money, credit_card, options = {})
       profile_id = credit_card.gateway_customer_profile_id
       if VALID_CCS.include? credit_card.number or (profile_id and profile_id.starts_with? 'BGS-')
-        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345', :avs_result => { :code => 'D' })
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345', avs_result: { code: 'D' })
       else
-        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', { :message => 'Bogus Gateway: Forced failure' }, :test => true)
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', { message: 'Bogus Gateway: Forced failure' }, test: true)
       end
     end
 
     def purchase(money, credit_card, options = {})
       profile_id = credit_card.gateway_customer_profile_id
       if VALID_CCS.include? credit_card.number  or (profile_id and profile_id.starts_with? 'BGS-')
-        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345', :avs_result => { :code => 'M' })
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345', avs_result: { code: 'M' })
       else
-        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', :message => 'Bogus Gateway: Forced failure', :test => true)
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', message: 'Bogus Gateway: Forced failure', test: true)
       end
     end
 
     def credit(money, credit_card, response_code, options = {})
-      ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345')
+      ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345')
     end
 
     def capture(money, authorization, gateway_options)
       if authorization == '12345'
-        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true)
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true)
       else
-        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', :error => 'Bogus Gateway: Forced failure', :test => true)
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', error: 'Bogus Gateway: Forced failure', test: true)
       end
 
     end
 
     def void(response_code, credit_card, options = {})
-      ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345')
+      ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345')
     end
 
     def cancel(_response_code)
@@ -82,8 +82,8 @@ module Spree
         record = true
         prefix = success ? 'BGS' : 'FAIL'
         while record
-          random = "#{prefix}-#{Array.new(6){rand(6)}.join}"
-          record = CreditCard.where(:gateway_customer_profile_id => random).first
+          random = "#{ prefix }-#{ Array.new(6) { rand(6) }.join }"
+          record = CreditCard.find_by(gateway_customer_profile_id: random)
         end
         random
       end

data/app/models/spree/gateway/bogus_simple.rb

@@ -8,17 +8,17 @@ module Spree
 
     def authorize(money, credit_card, options = {})
       if VALID_CCS.include? credit_card.number
-        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345', :avs_result => { :code => 'A' })
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345', avs_result: { code: 'A' })
       else
-        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', { :message => 'Bogus Gateway: Forced failure' }, :test => true)
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', { message: 'Bogus Gateway: Forced failure' }, test: true)
       end
     end
 
     def purchase(money, credit_card, options = {})
       if VALID_CCS.include? credit_card.number
-        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345', :avs_result => { :code => 'A' })
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345', avs_result: { code: 'A' })
       else
-        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', :message => 'Bogus Gateway: Forced failure', :test => true)
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', message: 'Bogus Gateway: Forced failure', test: true)
       end
     end
 

data/app/models/spree/gateway.rb

@@ -17,7 +17,7 @@ module Spree
       gateway_options = options
       gateway_options.delete :login if gateway_options.has_key?(:login) and gateway_options[:login].nil?
       if gateway_options[:server]
-        ActiveMerchant::Billing::Base.gateway_mode = gateway_options[:server].to_sym
+        ActiveMerchant::Billing::Base.mode = gateway_options[:server].to_sym
       end
       @provider ||= provider_class.new(gateway_options)
     end

data/app/models/spree/image.rb

@@ -9,8 +9,8 @@ module Spree
                       path: ':rails_root/public/spree/products/:id/:style/:basename.:extension',
                       convert_options: { all: '-strip -auto-orient -colorspace sRGB' }
     validates_attachment :attachment,
-      :presence => true,
-      :content_type => { :content_type => %w(image/jpeg image/jpg image/png image/gif) }
+      presence: true,
+      content_type: { content_type: %w(image/jpeg image/jpg image/png image/gif) }
 
     # save the w,h of the original image (from which others can be calculated)
     # we need to look at the write-queue for images which have not been saved yet

data/app/models/spree/inventory_unit.rb

@@ -4,7 +4,7 @@ module Spree
     with_options inverse_of: :inventory_units do
       belongs_to :variant, class_name: "Spree::Variant"
       belongs_to :order, class_name: "Spree::Order"
-      belongs_to :shipment, class_name: "Spree::Shipment", touch: true
+      belongs_to :shipment, class_name: "Spree::Shipment", touch: true, optional: true
       belongs_to :return_authorization, class_name: "Spree::ReturnAuthorization"
       belongs_to :line_item, class_name: "Spree::LineItem"
     end
@@ -14,13 +14,14 @@ module Spree
 
     scope :backordered, -> { where state: 'backordered' }
     scope :on_hand, -> { where state: 'on_hand' }
+    scope :on_hand_or_backordered, -> { where state: ['backordered', 'on_hand'] }
     scope :shipped, -> { where state: 'shipped' }
     scope :returned, -> { where state: 'returned' }
     scope :backordered_per_variant, ->(stock_item) do
       includes(:shipment, :order)
-        .where("spree_shipments.state != 'canceled'").references(:shipment)
+        .where.not(spree_shipments: { state: 'canceled' })
         .where(variant_id: stock_item.variant_id)
-        .where('spree_orders.completed_at is not null')
+        .where.not(spree_orders: { completed_at: nil })
         .backordered.order("spree_orders.completed_at ASC")
     end
 
@@ -52,13 +53,8 @@ module Spree
       end
     end
 
-    def self.finalize_units!(inventory_units)
-      inventory_units.map do |iu|
-        iu.update_columns(
-          pending: false,
-          updated_at: Time.current,
-        )
-      end
+    def self.finalize_units!
+      update_all(pending: false, updated_at: Time.current)
     end
 
     def find_stock_item

data/app/models/spree/line_item.rb

@@ -16,12 +16,12 @@ module Spree
     before_validation :copy_price
     before_validation :copy_tax_category
 
-    validates :variant, presence: true
+    validates :variant, :order, presence: true
     validates :quantity, numericality: { only_integer: true, message: Spree.t('validation.must_be_int') }
     validates :price, numericality: true
 
     validates_with Stock::AvailabilityValidator
-    validate :ensure_proper_currency
+    validate :ensure_proper_currency, if: -> { order.present? }
 
     before_destroy :update_inventory
     before_destroy :destroy_inventory_units
@@ -131,7 +131,7 @@ module Spree
     end
 
     def destroy_inventory_units
-      inventory_units.destroy_all
+      throw(:abort) unless inventory_units.destroy_all
     end
 
     def update_adjustments

data/app/models/spree/order_contents.rb

@@ -82,8 +82,10 @@ module Spree
         line_item.quantity += quantity.to_i
         line_item.currency = currency unless currency.nil?
       else
-        opts = { currency: order.currency }.merge ActionController::Parameters.new(options).
-                                            permit(PermittedAttributes.line_item_attributes)
+        opts = ActionController::Parameters.new(options.to_h)
+                                           .permit(PermittedAttributes.line_item_attributes)
+                                           .to_h
+                                           .merge( { currency: order.currency } )
         line_item = order.line_items.new(quantity: quantity,
                                           variant: variant,
                                           options: opts)

data/app/models/spree/payment/processing.rb

@@ -143,7 +143,7 @@ module Spree
       end
 
       def record_response(response)
-        log_entries.create!(:details => response.to_yaml)
+        log_entries.create!(details: response.to_yaml)
       end
 
       def protect_from_connection_error

data/app/models/spree/preferences/store.rb

@@ -24,7 +24,7 @@ module Spree::Preferences
 
     def exist?(key)
       @cache.exist?(key) ||
-      should_persist? && Spree::Preference.where(:key => key).exists?
+      should_persist? && Spree::Preference.where(key: key).exists?
     end
 
     def get(key)
@@ -73,7 +73,7 @@ module Spree::Preferences
     def persist(cache_key, value)
       return unless should_persist?
 
-      preference = Spree::Preference.where(:key => cache_key).first_or_initialize
+      preference = Spree::Preference.where(key: cache_key).first_or_initialize
       preference.value = value
       preference.save
     end
@@ -86,7 +86,7 @@ module Spree::Preferences
     end
 
     def should_persist?
-      @persistence && ActiveRecord::Base.connected? && Spree::Preference.table_exists?
+      @persistence and Spree::Preference.table_exists?
     end
 
   end

data/app/models/spree/product/scopes.rb

@@ -39,34 +39,34 @@ module Spree
     add_simple_scopes simple_scopes
 
     add_search_scope :ascend_by_master_price do
-      joins(:master => :default_price).order("#{price_table_name}.amount ASC")
+      joins(master: :default_price).order("#{price_table_name}.amount ASC")
     end
 
     add_search_scope :descend_by_master_price do
-      joins(:master => :default_price).order("#{price_table_name}.amount DESC")
+      joins(master: :default_price).order("#{price_table_name}.amount DESC")
     end
 
     add_search_scope :price_between do |low, high|
-      joins(:master => :default_price).where(Price.table_name => { :amount => low..high })
+      joins(master: :default_price).where(Price.table_name => { amount: low..high })
     end
 
     add_search_scope :master_price_lte do |price|
-      joins(:master => :default_price).where("#{price_table_name}.amount <= ?", price)
+      joins(master: :default_price).where("#{price_table_name}.amount <= ?", price)
     end
 
     add_search_scope :master_price_gte do |price|
-      joins(:master => :default_price).where("#{price_table_name}.amount >= ?", price)
+      joins(master: :default_price).where("#{price_table_name}.amount >= ?", price)
     end
 
     # This scope selects products in taxon AND all its descendants
     # If you need products only within one taxon use
     #
-    #   Spree::Product.joins(:taxons).where(Taxon.table_name => { :id => taxon.id })
+    #   Spree::Product.joins(:taxons).where(Taxon.table_name => { id: taxon.id })
     #
     # If you're using count on the result of this scope, you must use the
     # `:distinct` option as well:
     #
-    #   Spree::Product.in_taxon(taxon).count(:distinct => true)
+    #   Spree::Product.in_taxon(taxon).count(distinct: true)
     #
     # This is so that the count query is distinct'd:
     #
@@ -162,8 +162,8 @@ module Spree
     # there is alternative faster and more elegant solution, it has small drawback though,
     # it doesn stack with other scopes :/
     #
-    # :joins => "LEFT OUTER JOIN (SELECT line_items.variant_id as vid, COUNT(*) as cnt FROM line_items GROUP BY line_items.variant_id) AS popularity_count ON variants.id = vid",
-    # :order => 'COALESCE(cnt, 0) DESC'
+    # joins: "LEFT OUTER JOIN (SELECT line_items.variant_id as vid, COUNT(*) as cnt FROM line_items GROUP BY line_items.variant_id) AS popularity_count ON variants.id = vid",
+    # order: 'COALESCE(cnt, 0) DESC'
     add_search_scope :descend_by_popularity do
       joins(:master).
       order(%Q{
@@ -197,12 +197,12 @@ module Spree
     # Can't use add_search_scope for this as it needs a default argument
     def self.available(available_on = nil, currency = nil)
       available_on ||= Time.current
-      not_discontinued.joins(master: :prices).where("#{Product.quoted_table_name}.available_on <= ?", available_on).uniq
+      not_discontinued.joins(master: :prices).where("#{Product.quoted_table_name}.available_on <= ?", available_on).distinct
     end
     search_scopes << :available
 
     def self.active(currency = nil)
-      not_discontinued.available(nil, currency)
+      available(nil, currency)
     end
     search_scopes << :active
 
@@ -228,7 +228,7 @@ module Spree
       #
       # Don't allow sort_column, a variable coming from params,
       # to be anything but a column in the database
-      if ActiveRecord::Base.connection.adapter_name == 'PostgreSQL' && !column_names.include?(sort_column)
+      if ApplicationRecord.connection.adapter_name == 'PostgreSQL' && !column_names.include?(sort_column)
         all
       else
         distinct
@@ -260,7 +260,7 @@ module Spree
         ids_or_records_or_names.flatten.map { |t|
           case t
           when Integer then Taxon.find_by(id: t)
-          when ActiveRecord::Base then t
+          when ApplicationRecord then t
           when String
             Taxon.find_by(name: t) ||
             Taxon.where("#{taxons}.permalink LIKE ? OR #{taxons}.permalink = ?", "%/#{t}/", "#{t}/").first

data/app/models/spree/product.rb

@@ -212,7 +212,7 @@ module Spree
     end
 
     def set_property(property_name, property_value, property_presentation = property_name)
-      ActiveRecord::Base.transaction do
+      ApplicationRecord.transaction do
         # Works around spree_i18n #301
         property = Property.create_with(presentation: property_presentation).find_or_create_by(name: property_name)
         product_property = ProductProperty.where(product: self, property: property).first_or_initialize
@@ -269,7 +269,7 @@ module Spree
           price: master.price
         )
       end
-      save
+      throw(:abort) unless save
     end
 
     def ensure_master

data/app/models/spree/promotion/rules/taxon.rb

@@ -44,7 +44,7 @@ module Spree
 
         # All taxons in an order
         def order_taxons(order)
-          Spree::Taxon.joins(products: {variants_including_master: :line_items}).where(spree_line_items: {order_id: order.id}).uniq
+          Spree::Taxon.joins(products: {variants_including_master: :line_items}).where(spree_line_items: {order_id: order.id}).distinct
         end
 
         # ids of taxons rules and taxons rules children

data/app/models/spree/promotion.rb

@@ -30,7 +30,7 @@ module Spree
     scope :coupons, -> { where.not(code: nil) }
     scope :advertised, -> { where(advertise: true) }
     scope :applied, lambda {
-      joins(<<-SQL).uniq
+      joins(<<-SQL).distinct
         INNER JOIN spree_order_promotions
         ON spree_order_promotions.promotion_id = #{table_name}.id
       SQL

data/app/models/spree/promotion_handler/cart.rb

@@ -31,20 +31,7 @@ module Spree
       private
 
       def promotions
-        # AR cannot bind raw ASTs to prepared statements. There always must be a manager around.
-        # Also Postgresql requires an aliased table for `SELECT * FROM (subexpression) AS alias`.
-        # And Sqlite3 cannot work on outher parenthesis from `(left UNION right)`.
-        # So this construct makes both happy.
-        select = Arel::SelectManager.new(Promotion.arel_engine)
-        select.from(
-          Promotion.arel_table.create_table_alias(
-            order.promotions.active.union(Promotion.active.where(code: nil, path: nil)),
-            Promotion.table_name
-          )
-        )
-        select.project(Arel.star)
-
-        Promotion.find_by_sql(select.to_sql)
+        Promotion.find_by_sql("#{order.promotions.active.to_sql} UNION #{Promotion.active.where(code: nil, path: nil).to_sql}")
       end
     end
   end

data/app/models/spree/promotion_handler/page.rb

@@ -10,14 +10,14 @@ module Spree
 
       def activate
         if promotion && promotion.eligible?(order)
-          promotion.activate(:order => order)
+          promotion.activate(order: order)
         end
       end
 
       private
 
         def promotion
-          @promotion ||= Promotion.active.find_by(:path => path)
+          @promotion ||= Promotion.active.find_by(path: path)
         end
     end
   end

data/app/models/spree/refund_reason.rb

@@ -7,7 +7,7 @@ module Spree
     has_many :refunds, dependent: :restrict_with_error
 
     def self.return_processing_reason
-      find_by!(name: RETURN_PROCESSING_REASON, mutable: false)
+      find_by(name: RETURN_PROCESSING_REASON, mutable: false)
     end
   end
 end

data/app/models/spree/reimbursement_type.rb

@@ -2,7 +2,11 @@ module Spree
   class ReimbursementType < Spree::Base
     include Spree::NamedType
 
-    ORIGINAL = 'original'
+    KINDS = %w(Spree::ReimbursementType::Credit
+               Spree::ReimbursementType::Exchange
+               Spree::ReimbursementType::OriginalPayment
+               Spree::ReimbursementType::StoreCredit).freeze
+    ORIGINAL = 'original'.freeze
 
     has_many :return_items
 

data/app/models/spree/return_item.rb

@@ -102,7 +102,7 @@ module Spree
         transition to: :manual_intervention_required, from: [:accepted, :pending, :manual_intervention_required]
       end
 
-      after_transition any => any, :do => :persist_acceptance_status_errors
+      after_transition any => any, do: :persist_acceptance_status_errors
     end
 
     def self.from_inventory_unit(inventory_unit)

data/app/models/spree/stock/inventory_unit_builder.rb

@@ -10,7 +10,7 @@ module Spree
           line_item.quantity.times.map do |i|
             @order.inventory_units.build(
               pending: true,
-              variant: line_item.variant,
+              variant_id: line_item.variant_id,
               line_item: line_item,
               order: @order
             )

data/app/models/spree/stock_movement.rb

@@ -1,5 +1,10 @@
 module Spree
   class StockMovement < Spree::Base
+    QUANTITY_LIMITS = {
+      max: 2**31 - 1,
+      min: -2**31
+    }.freeze
+
     belongs_to :stock_item, class_name: 'Spree::StockItem', inverse_of: :stock_movements
     belongs_to :originator, polymorphic: true
 
@@ -8,11 +13,11 @@ module Spree
     with_options presence: true do
       validates :stock_item
       validates :quantity, numericality: {
-                                            greater_than_or_equal_to: -2**31,
-                                            less_than_or_equal_to: 2**31 - 1,
-                                            only_integer: true,
-                                            allow_nil: true
-                                          }
+        greater_than_or_equal_to: QUANTITY_LIMITS[:min],
+        less_than_or_equal_to: QUANTITY_LIMITS[:max],
+        only_integer: true,
+        allow_nil: true
+      }
     end
 
     scope :recent, -> { order(created_at: :desc) }
@@ -20,7 +25,7 @@ module Spree
     self.whitelisted_ransackable_attributes = ['quantity']
 
     def readonly?
-      !new_record?
+      persisted?
     end
 
     private

data/app/models/spree/store.rb

@@ -38,6 +38,7 @@ module Spree
     def validate_not_default
       if default
         errors.add(:base, :cannot_destroy_default_store)
+        throw(:abort)
       end
     end
 

data/app/models/spree/store_credit.rb

@@ -238,7 +238,7 @@ module Spree
     def validate_no_amount_used
       if amount_used > 0
         errors.add(:amount_used, :greater_than_zero_restrict_delete)
-        false
+        throw(:abort)
       end
     end
 

data/app/models/spree/taxon.rb

@@ -13,10 +13,10 @@ module Spree
     has_many :classifications, -> { order(:position) }, dependent: :delete_all, inverse_of: :taxon
     has_many :products, through: :classifications
 
-    has_many :prototype_taxons, class_name: 'Spree::PrototypeTaxon'
+    has_many :prototype_taxons, class_name: 'Spree::PrototypeTaxon', dependent: :destroy
     has_many :prototypes, through: :prototype_taxons, class_name: 'Spree::Prototype'
 
-    has_many :promotion_rule_taxons, class_name: 'Spree::PromotionRuleTaxon'
+    has_many :promotion_rule_taxons, class_name: 'Spree::PromotionRuleTaxon', dependent: :destroy
     has_many :promotion_rules, through: :promotion_rule_taxons, class_name: 'Spree::PromotionRule'
 
     validates :name, presence: true

data/app/models/spree/variant.rb

@@ -58,15 +58,18 @@ module Spree
     scope :in_stock, -> { joins(:stock_items).where('count_on_hand > ? OR track_inventory = ?', 0, false) }
 
     scope :not_discontinued, -> do
-      variant_table_name = Variant.quoted_table_name
-      where("#{variant_table_name}.discontinue_on IS NULL OR #{variant_table_name}.discontinue_on >= ?", Time.current)
+      where(
+        arel_table[:discontinue_on].eq(nil).or(
+          arel_table[:discontinue_on].gteq(Time.current)
+        )
+      )
     end
 
     scope :not_deleted, -> { where("#{Variant.quoted_table_name}.deleted_at IS NULL") }
 
     scope :for_currency_and_available_price_amount, -> (currency) do
       currency ||= Spree::Config[:currency]
-      joins(:prices).where("spree_prices.currency = ?", currency).where("spree_prices.amount IS NOT NULL").uniq
+      joins(:prices).where("spree_prices.currency = ?", currency).where("spree_prices.amount IS NOT NULL").distinct
     end
 
     scope :active, -> (currency = nil) do
@@ -264,7 +267,7 @@ module Spree
     def ensure_no_line_items
       if line_items.any?
         errors.add(:base, Spree.t(:cannot_destroy_if_attached_to_line_items))
-        return false
+        throw(:abort)
       end
     end