solidus_core 2.9.6 → 2.10.0.beta1

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

@@ -2,159 +2,162 @@
 
 module Spree
   class Product < Spree::Base
-    cattr_accessor :search_scopes do
-      []
-    end
+    module Scopes
+      def self.prepended(base)
+        base.class_eval do
+          cattr_accessor :search_scopes do
+            []
+          end
 
-    def self.add_search_scope(name, &block)
-      singleton_class.send(:define_method, name.to_sym, &block)
-      search_scopes << name.to_sym
-    end
+          def self.add_search_scope(name, &block)
+            singleton_class.send(:define_method, name.to_sym, &block)
+            search_scopes << name.to_sym
+          end
 
-    def self.property_conditions(property)
-      properties = Property.table_name
-      case property
-      when String   then { "#{properties}.name" => property }
-      when Property then { "#{properties}.id" => property.id }
-      else { "#{properties}.id" => property.to_i }
-      end
-    end
+          def self.property_conditions(property)
+            properties = Property.table_name
+            case property
+            when String   then { "#{properties}.name" => property }
+            when Property then { "#{properties}.id" => property.id }
+            else { "#{properties}.id" => property.to_i }
+            end
+          end
 
-    scope :ascend_by_updated_at, -> { order(updated_at: :asc) }
-    scope :descend_by_updated_at, -> { order(updated_at: :desc) }
-    scope :ascend_by_name, -> { order(name: :asc) }
-    scope :descend_by_name, -> { order(name: :desc) }
+          scope :ascend_by_updated_at, -> { order(updated_at: :asc) }
+          scope :descend_by_updated_at, -> { order(updated_at: :desc) }
+          scope :ascend_by_name, -> { order(name: :asc) }
+          scope :descend_by_name, -> { order(name: :desc) }
 
-    add_search_scope :ascend_by_master_price do
-      joins(master: :default_price).order(Spree::Price.arel_table[:amount].asc)
-    end
+          add_search_scope :ascend_by_master_price do
+            joins(master: :default_price).order(Spree::Price.arel_table[:amount].asc)
+          end
 
-    add_search_scope :descend_by_master_price do
-      joins(master: :default_price).order(Spree::Price.arel_table[:amount].desc)
-    end
+          add_search_scope :descend_by_master_price do
+            joins(master: :default_price).order(Spree::Price.arel_table[:amount].desc)
+          end
 
-    add_search_scope :price_between do |low, high|
-      joins(master: :default_price).where(Price.table_name => { amount: low..high })
-    end
+          add_search_scope :price_between do |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)
-    end
+          add_search_scope :master_price_lte do |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)
-    end
+          add_search_scope :master_price_gte do |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 })
-    #
-    # 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)
-    #
-    # This is so that the count query is distinct'd:
-    #
-    #   SELECT COUNT(DISTINCT "spree_products"."id") ...
-    #
-    #   vs.
-    #
-    #   SELECT COUNT(*) ...
-    add_search_scope :in_taxon do |taxon|
-      includes(:classifications)
-        .where('spree_products_taxons.taxon_id' => taxon.self_and_descendants.pluck(:id))
-        .select(Spree::Classification.arel_table[:position])
-        .order(Spree::Classification.arel_table[:position].asc)
-    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 })
+          #
+          # 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)
+          #
+          # This is so that the count query is distinct'd:
+          #
+          #   SELECT COUNT(DISTINCT "spree_products"."id") ...
+          #
+          #   vs.
+          #
+          #   SELECT COUNT(*) ...
+          add_search_scope :in_taxon do |taxon|
+            includes(:classifications)
+              .where('spree_products_taxons.taxon_id' => taxon.self_and_descendants.pluck(:id))
+              .select(Spree::Classification.arel_table[:position])
+              .order(Spree::Classification.arel_table[:position].asc)
+          end
 
-    # This scope selects products in all taxons AND all its descendants
-    # If you need products only within one taxon use
-    #
-    #   Spree::Product.taxons_id_eq([x,y])
-    add_search_scope :in_taxons do |*taxons|
-      taxons = get_taxons(taxons)
-      taxons.first ? prepare_taxon_conditions(taxons) : where(nil)
-    end
+          # This scope selects products in all taxons AND all its descendants
+          # If you need products only within one taxon use
+          #
+          #   Spree::Product.taxons_id_eq([x,y])
+          add_search_scope :in_taxons do |*taxons|
+            taxons = get_taxons(taxons)
+            taxons.first ? prepare_taxon_conditions(taxons) : where(nil)
+          end
 
-    # a scope that finds all products having property specified by name, object or id
-    add_search_scope :with_property do |property|
-      joins(:properties).where(property_conditions(property))
-    end
+          # a scope that finds all products having property specified by name, object or id
+          add_search_scope :with_property do |property|
+            joins(:properties).where(property_conditions(property))
+          end
 
-    # a simple test for product with a certain property-value pairing
-    # note that it can test for properties with NULL values, but not for absent values
-    add_search_scope :with_property_value do |property, value|
-      joins(:properties)
-        .where("#{Spree::ProductProperty.table_name}.value = ?", value)
-        .where(property_conditions(property))
-    end
+          # a simple test for product with a certain property-value pairing
+          # note that it can test for properties with NULL values, but not for absent values
+          add_search_scope :with_property_value do |property, value|
+            joins(:properties)
+              .where("#{Spree::ProductProperty.table_name}.value = ?", value)
+              .where(property_conditions(property))
+          end
 
-    add_search_scope :with_option do |option|
-      option_types = Spree::OptionType.table_name
-      conditions = case option
-                   when String     then { "#{option_types}.name" => option }
-                   when OptionType then { "#{option_types}.id" => option.id }
-      else { "#{option_types}.id" => option.to_i }
-      end
+          add_search_scope :with_option do |option|
+            option_types = Spree::OptionType.table_name
+            conditions = case option
+                         when String     then { "#{option_types}.name" => option }
+                         when OptionType then { "#{option_types}.id" => option.id }
+                         else { "#{option_types}.id" => option.to_i }
+            end
 
-      joins(:option_types).where(conditions)
-    end
+            joins(:option_types).where(conditions)
+          end
 
-    add_search_scope :with_option_value do |option, value|
-      option_values = Spree::OptionValue.table_name
-      option_type_id = case option
-                       when String then Spree::OptionType.find_by(name: option) || option.to_i
-                       when Spree::OptionType then option.id
-        else option.to_i
-      end
+          add_search_scope :with_option_value do |option, value|
+            option_values = Spree::OptionValue.table_name
+            option_type_id = case option
+                             when String then Spree::OptionType.find_by(name: option) || option.to_i
+                             when Spree::OptionType then option.id
+                             else option.to_i
+            end
 
-      conditions = "#{option_values}.name = ? AND #{option_values}.option_type_id = ?", value, option_type_id
-      group('spree_products.id').joins(variants_including_master: :option_values).where(conditions)
-    end
+            conditions = "#{option_values}.name = ? AND #{option_values}.option_type_id = ?", value, option_type_id
+            group('spree_products.id').joins(variants_including_master: :option_values).where(conditions)
+          end
 
-    # Finds all products which have either:
-    # 1) have an option value with the name matching the one given
-    # 2) have a product property with a value matching the one given
-    add_search_scope :with do |value|
-      includes(variants_including_master: :option_values).
-      includes(:product_properties).
-      where("#{Spree::OptionValue.table_name}.name = ? OR #{Spree::ProductProperty.table_name}.value = ?", value, value)
-    end
+          # Finds all products which have either:
+          # 1) have an option value with the name matching the one given
+          # 2) have a product property with a value matching the one given
+          add_search_scope :with do |value|
+            includes(variants_including_master: :option_values).
+              includes(:product_properties).
+              where("#{Spree::OptionValue.table_name}.name = ? OR #{Spree::ProductProperty.table_name}.value = ?", value, value)
+          end
 
-    # Finds all products that have a name containing the given words.
-    add_search_scope :in_name do |words|
-      like_any([:name], prepare_words(words))
-    end
+          # Finds all products that have a name containing the given words.
+          add_search_scope :in_name do |words|
+            like_any([:name], prepare_words(words))
+          end
 
-    # Finds all products that have a name or meta_keywords containing the given words.
-    add_search_scope :in_name_or_keywords do |words|
-      like_any([:name, :meta_keywords], prepare_words(words))
-    end
+          # Finds all products that have a name or meta_keywords containing the given words.
+          add_search_scope :in_name_or_keywords do |words|
+            like_any([:name, :meta_keywords], prepare_words(words))
+          end
 
-    # Finds all products that have a name, description, meta_description or meta_keywords containing the given keywords.
-    add_search_scope :in_name_or_description do |words|
-      like_any([:name, :description, :meta_description, :meta_keywords], prepare_words(words))
-    end
+          # Finds all products that have a name, description, meta_description or meta_keywords containing the given keywords.
+          add_search_scope :in_name_or_description do |words|
+            like_any([:name, :description, :meta_description, :meta_keywords], prepare_words(words))
+          end
 
-    # Finds all products that have the ids matching the given collection of ids.
-    # Alternatively, you could use find(collection_of_ids), but that would raise an exception if one product couldn't be found
-    add_search_scope :with_ids do |*ids|
-      where(id: ids)
-    end
+          # Finds all products that have the ids matching the given collection of ids.
+          # Alternatively, you could use find(collection_of_ids), but that would raise an exception if one product couldn't be found
+          add_search_scope :with_ids do |*ids|
+            where(id: ids)
+          end
 
-    # Sorts products from most popular (popularity is extracted from how many
-    # times use has put product in cart, not completed orders)
-    #
-    # 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'
-    add_search_scope :descend_by_popularity do
-      joins(:master).
-      order(%{
+          # Sorts products from most popular (popularity is extracted from how many
+          # times use has put product in cart, not completed orders)
+          #
+          # 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'
+          add_search_scope :descend_by_popularity do
+            joins(:master).
+              order(%{
            COALESCE((
              SELECT
                COUNT(#{Spree::LineItem.quoted_table_name}.id)
@@ -168,93 +171,97 @@ module Spree
                popular_variants.product_id = #{Spree::Product.quoted_table_name}.id
            ), 0) DESC
         })
-    end
-
-    add_search_scope :not_deleted do
-      where("#{Spree::Product.quoted_table_name}.deleted_at IS NULL or #{Spree::Product.quoted_table_name}.deleted_at >= ?", Time.current)
-    end
-
-    scope :with_master_price, -> do
-      joins(:master).where(Spree::Price.where(Spree::Variant.arel_table[:id].eq(Spree::Price.arel_table[:variant_id])).arel.exists)
-    end
-
-    # Can't use add_search_scope for this as it needs a default argument
-    def self.available(available_on = nil)
-      with_master_price.where("#{Spree::Product.quoted_table_name}.available_on <= ?", available_on || Time.current)
-    end
-    search_scopes << :available
-
-    add_search_scope :taxons_name_eq do |name|
-      group("spree_products.id").joins(:taxons).where(Spree::Taxon.arel_table[:name].eq(name))
-    end
-
-    def self.with_variant_sku_cont(sku)
-      sku_match = "%#{sku}%"
-      variant_table = Spree::Variant.arel_table
-      subquery = Spree::Variant.where(variant_table[:sku].matches(sku_match).and(variant_table[:product_id].eq(arel_table[:id])))
-      where(subquery.arel.exists)
-    end
+          end
 
-    def self.distinct_by_product_ids(sort_order = nil)
-      Spree::Deprecation.warn "Product.distinct_by_product_ids is deprecated and should not be used"
-
-      sort_column = sort_order.split(" ").first
-
-      # Postgres will complain when using ordering by expressions not present in
-      # SELECT DISTINCT. e.g.
-      #
-      #   PG::InvalidColumnReference: ERROR:  for SELECT DISTINCT, ORDER BY
-      #   expressions must appear in select list. e.g.
-      #
-      #   SELECT  DISTINCT "spree_products".* FROM "spree_products" LEFT OUTER JOIN
-      #   "spree_variants" ON "spree_variants"."product_id" = "spree_products"."id" AND "spree_variants"."is_master" = 't'
-      #   AND "spree_variants"."deleted_at" IS NULL LEFT OUTER JOIN "spree_prices" ON
-      #   "spree_prices"."variant_id" = "spree_variants"."id" AND "spree_prices"."currency" = 'USD'
-      #   AND "spree_prices"."deleted_at" IS NULL WHERE "spree_products"."deleted_at" IS NULL AND ('t'='t')
-      #   ORDER BY "spree_prices"."amount" ASC LIMIT 10 OFFSET 0
-      #
-      # 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)
-        all
-      else
-        distinct
-      end
-    end
+          add_search_scope :not_deleted do
+            where("#{Spree::Product.quoted_table_name}.deleted_at IS NULL or #{Spree::Product.quoted_table_name}.deleted_at >= ?", Time.current)
+          end
 
-    class << self
-      private
+          scope :with_master_price, -> do
+            joins(:master).where(Spree::Price.where(Spree::Variant.arel_table[:id].eq(Spree::Price.arel_table[:variant_id])).arel.exists)
+          end
+          # Can't use add_search_scope for this as it needs a default argument
+          def self.available(available_on = nil)
+            with_master_price.where("#{Spree::Product.quoted_table_name}.available_on <= ?", available_on || Time.current)
+          end
+          search_scopes << :available
 
-      def price_table_name
-        Spree::Price.quoted_table_name
-      end
+          add_search_scope :taxons_name_eq do |name|
+            group("spree_products.id").joins(:taxons).where(Spree::Taxon.arel_table[:name].eq(name))
+          end
 
-      # specifically avoid having an order for taxon search (conflicts with main order)
-      def prepare_taxon_conditions(taxons)
-        ids = taxons.map { |taxon| taxon.self_and_descendants.pluck(:id) }.flatten.uniq
-        joins(:taxons).where("#{Spree::Taxon.table_name}.id" => ids)
-      end
+          def self.with_variant_sku_cont(sku)
+            sku_match = "%#{sku}%"
+            variant_table = Spree::Variant.arel_table
+            subquery = Spree::Variant.where(variant_table[:sku].matches(sku_match).and(variant_table[:product_id].eq(arel_table[:id])))
+            where(subquery.arel.exists)
+          end
 
-      # Produce an array of keywords for use in scopes.
-      # Always return array with at least an empty string to avoid SQL errors
-      def prepare_words(words)
-        return [''] if words.blank?
-        a = words.split(/[,\s]/).map(&:strip)
-        a.any? ? a : ['']
-      end
+          def self.distinct_by_product_ids(sort_order = nil)
+            Spree::Deprecation.warn "Product.distinct_by_product_ids is deprecated and should not be used"
+
+            sort_column = sort_order.split(" ").first
+
+            # Postgres will complain when using ordering by expressions not present in
+            # SELECT DISTINCT. e.g.
+            #
+            #   PG::InvalidColumnReference: ERROR:  for SELECT DISTINCT, ORDER BY
+            #   expressions must appear in select list. e.g.
+            #
+            #   SELECT  DISTINCT "spree_products".* FROM "spree_products" LEFT OUTER JOIN
+            #   "spree_variants" ON "spree_variants"."product_id" = "spree_products"."id" AND "spree_variants"."is_master" = 't'
+            #   AND "spree_variants"."deleted_at" IS NULL LEFT OUTER JOIN "spree_prices" ON
+            #   "spree_prices"."variant_id" = "spree_variants"."id" AND "spree_prices"."currency" = 'USD'
+            #   AND "spree_prices"."deleted_at" IS NULL WHERE "spree_products"."deleted_at" IS NULL AND ('t'='t')
+            #   ORDER BY "spree_prices"."amount" ASC LIMIT 10 OFFSET 0
+            #
+            # 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)
+              all
+            else
+              distinct
+            end
+          end
 
-      def get_taxons(*ids_or_records_or_names)
-        taxons = Spree::Taxon.table_name
-        ids_or_records_or_names.flatten.map { |t|
-          case t
-          when Integer then Spree::Taxon.find_by(id: t)
-          when ActiveRecord::Base then t
-          when String
-            Spree::Taxon.find_by(name: t) ||
-              Spree::Taxon.where("#{taxons}.permalink LIKE ? OR #{taxons}.permalink = ?", "%/#{t}/", "#{t}/").first
+          class << self
+            private
+
+            def price_table_name
+              Spree::Price.quoted_table_name
+            end
+
+            # specifically avoid having an order for taxon search (conflicts with main order)
+            def prepare_taxon_conditions(taxons)
+              ids = taxons.map { |taxon| taxon.self_and_descendants.pluck(:id) }.flatten.uniq
+              joins(:taxons).where("#{Spree::Taxon.table_name}.id" => ids)
+            end
+
+            # Produce an array of keywords for use in scopes.
+            # Always return array with at least an empty string to avoid SQL errors
+            def prepare_words(words)
+              return [''] if words.blank?
+              a = words.split(/[,\s]/).map(&:strip)
+              a.any? ? a : ['']
+            end
+
+            def get_taxons(*ids_or_records_or_names)
+              taxons = Spree::Taxon.table_name
+              ids_or_records_or_names.flatten.map { |t|
+                case t
+                when Integer then Spree::Taxon.find_by(id: t)
+                when ActiveRecord::Base then t
+                when String
+                  Spree::Taxon.find_by(name: t) ||
+                    Spree::Taxon.where("#{taxons}.permalink LIKE ? OR #{taxons}.permalink = ?", "%/#{t}/", "#{t}/").first
+                end
+              }.compact.flatten.uniq
+            end
           end
-        }.compact.flatten.uniq
+        end
       end
+
+      ::Spree::Product.prepend self
     end
   end
 end

data/app/models/spree/product.rb

@@ -44,8 +44,8 @@ module Spree
     has_many :product_promotion_rules, dependent: :destroy
     has_many :promotion_rules, through: :product_promotion_rules
 
-    belongs_to :tax_category, class_name: 'Spree::TaxCategory'
-    belongs_to :shipping_category, class_name: 'Spree::ShippingCategory', inverse_of: :products
+    belongs_to :tax_category, class_name: 'Spree::TaxCategory', optional: true
+    belongs_to :shipping_category, class_name: 'Spree::ShippingCategory', inverse_of: :products, optional: true
 
     has_one :master,
       -> { where(is_master: true).with_deleted },

data/app/models/spree/product_option_type.rb

@@ -2,8 +2,8 @@
 
 module Spree
   class ProductOptionType < Spree::Base
-    belongs_to :product, class_name: 'Spree::Product', inverse_of: :product_option_types, touch: true
-    belongs_to :option_type, class_name: 'Spree::OptionType', inverse_of: :product_option_types
+    belongs_to :product, class_name: 'Spree::Product', inverse_of: :product_option_types, touch: true, optional: true
+    belongs_to :option_type, class_name: 'Spree::OptionType', inverse_of: :product_option_types, optional: true
     acts_as_list scope: :product
   end
 end

data/app/models/spree/product_promotion_rule.rb

@@ -2,7 +2,7 @@
 
 module Spree
   class ProductPromotionRule < Spree::Base
-    belongs_to :product
-    belongs_to :promotion_rule
+    belongs_to :product, optional: true
+    belongs_to :promotion_rule, optional: true
   end
 end

data/app/models/spree/product_property.rb

@@ -6,8 +6,8 @@ module Spree
 
     acts_as_list scope: :product
 
-    belongs_to :product, touch: true, class_name: 'Spree::Product', inverse_of: :product_properties
-    belongs_to :property, class_name: 'Spree::Property', inverse_of: :product_properties
+    belongs_to :product, touch: true, class_name: 'Spree::Product', inverse_of: :product_properties, optional: true
+    belongs_to :property, class_name: 'Spree::Property', inverse_of: :product_properties, optional: true
 
     self.whitelisted_ransackable_attributes = ['value']
   end

data/app/models/spree/promotion.rb

@@ -7,7 +7,7 @@ module Spree
 
     attr_reader :eligibility_errors
 
-    belongs_to :promotion_category
+    belongs_to :promotion_category, optional: true
 
     has_many :promotion_rules, autosave: true, dependent: :destroy, inverse_of: :promotion
     alias_method :rules, :promotion_rules

data/app/models/spree/promotion_action.rb

@@ -14,7 +14,7 @@ module Spree
     include Discard::Model
     self.discard_column = :deleted_at
 
-    belongs_to :promotion, class_name: 'Spree::Promotion', inverse_of: :promotion_actions
+    belongs_to :promotion, class_name: 'Spree::Promotion', inverse_of: :promotion_actions, optional: true
 
     scope :of_type, ->(t) { where(type: Array.wrap(t).map(&:to_s)) }
     scope :shipping, -> { of_type(Spree::Config.environment.promotions.shipping_actions.to_a) }

data/app/models/spree/promotion_code.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
 class Spree::PromotionCode < Spree::Base
-  belongs_to :promotion, inverse_of: :codes
-  belongs_to :promotion_code_batch, class_name: "Spree::PromotionCodeBatch"
+  belongs_to :promotion, inverse_of: :codes, optional: true
+  belongs_to :promotion_code_batch, class_name: "Spree::PromotionCodeBatch", optional: true
   has_many :adjustments
 
   validates :value, presence: true, uniqueness: { allow_blank: true }

data/app/models/spree/promotion_code_batch.rb

@@ -5,7 +5,7 @@ module Spree
     class CantProcessStartedBatch < StandardError
     end
 
-    belongs_to :promotion, class_name: "Spree::Promotion"
+    belongs_to :promotion, class_name: "Spree::Promotion", optional: true
     has_many :promotion_codes, class_name: "Spree::PromotionCode", dependent: :destroy
 
     validates :number_of_codes, numericality: { greater_than: 0 }

data/app/models/spree/promotion_rule.rb

@@ -3,7 +3,7 @@
 module Spree
   # Base class for all promotion rules
   class PromotionRule < Spree::Base
-    belongs_to :promotion, class_name: 'Spree::Promotion', inverse_of: :promotion_rules
+    belongs_to :promotion, class_name: 'Spree::Promotion', inverse_of: :promotion_rules, optional: true
 
     scope :of_type, ->(t) { where(type: t) }
 

data/app/models/spree/promotion_rule_role.rb

@@ -2,7 +2,7 @@
 
 module Spree
   class PromotionRuleRole < ActiveRecord::Base
-    belongs_to :promotion_rule, class_name: 'Spree::PromotionRule'
-    belongs_to :role, class_name: 'Spree::Role'
+    belongs_to :promotion_rule, class_name: 'Spree::PromotionRule', optional: true
+    belongs_to :role, class_name: 'Spree::Role', optional: true
   end
 end

data/app/models/spree/promotion_rule_store.rb

@@ -4,7 +4,7 @@ module Spree
   class PromotionRuleStore < Spree::Base
     self.table_name = "spree_promotion_rules_stores"
 
-    belongs_to :promotion_rule, class_name: "Spree::PromotionRule"
-    belongs_to :store, class_name: "Spree::Store"
+    belongs_to :promotion_rule, class_name: "Spree::PromotionRule", optional: true
+    belongs_to :store, class_name: "Spree::Store", optional: true
   end
 end

data/app/models/spree/promotion_rule_taxon.rb

@@ -2,7 +2,7 @@
 
 module Spree
   class PromotionRuleTaxon < Spree::Base
-    belongs_to :promotion_rule
-    belongs_to :taxon
+    belongs_to :promotion_rule, optional: true
+    belongs_to :taxon, optional: true
   end
 end

data/app/models/spree/promotion_rule_user.rb

@@ -4,7 +4,7 @@ module Spree
   class PromotionRuleUser < Spree::Base
     self.table_name = 'spree_promotion_rules_users'
 
-    belongs_to :promotion_rule, class_name: 'Spree::PromotionRule'
-    belongs_to :user, class_name: Spree::UserClassHandle.new
+    belongs_to :promotion_rule, class_name: 'Spree::PromotionRule', optional: true
+    belongs_to :user, class_name: Spree::UserClassHandle.new, optional: true
   end
 end

data/app/models/spree/refund.rb

@@ -2,9 +2,9 @@
 
 module Spree
   class Refund < Spree::Base
-    belongs_to :payment, inverse_of: :refunds
-    belongs_to :reason, class_name: 'Spree::RefundReason', foreign_key: :refund_reason_id
-    belongs_to :reimbursement, inverse_of: :refunds
+    belongs_to :payment, inverse_of: :refunds, optional: true
+    belongs_to :reason, class_name: 'Spree::RefundReason', foreign_key: :refund_reason_id, optional: true
+    belongs_to :reimbursement, inverse_of: :refunds, optional: true
 
     has_many :log_entries, as: :source
 

data/app/models/spree/reimbursement/credit.rb

@@ -6,8 +6,8 @@ module Spree
       class_attribute :default_creditable_class
       self.default_creditable_class = Spree::StoreCredit
 
-      belongs_to :reimbursement, inverse_of: :credits
-      belongs_to :creditable, polymorphic: true
+      belongs_to :reimbursement, inverse_of: :credits, optional: true
+      belongs_to :creditable, polymorphic: true, optional: true
 
       validates :creditable, presence: true