solidus_core 2.9.6 → 2.11.0

data/app/models/spree/product.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'discard'
-
 module Spree
   # Products represent an entity for sale in a store. Products can have
   # variations, called variants. Product properties include description,
@@ -15,17 +13,13 @@ module Spree
     extend FriendlyId
     friendly_id :slug_candidates, use: :history
 
-    acts_as_paranoid
-    include Spree::ParanoiaDeprecations
-
-    include Discard::Model
-    self.discard_column = :deleted_at
+    include Spree::SoftDeletable
 
     after_discard do
       variants_including_master.discard_all
       self.product_option_types = []
       self.product_properties = []
-      self.classifications = []
+      self.classifications.destroy_all
       self.product_promotion_rules = []
     end
 
@@ -44,11 +38,11 @@ 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 },
+      -> { where(is_master: true).with_discarded },
       inverse_of: :product,
       class_name: 'Spree::Variant',
       autosave: true
@@ -121,7 +115,7 @@ module Spree
     validates :name, presence: true
     validates :price, presence: true, if: proc { Spree::Config[:require_master_price] }
     validates :shipping_category_id, presence: true
-    validates :slug, presence: true, uniqueness: { allow_blank: true }
+    validates :slug, presence: true, uniqueness: { allow_blank: true, case_sensitive: true }
 
     attr_accessor :option_values_hash
 
@@ -134,7 +128,7 @@ module Spree
     self.whitelisted_ransackable_attributes = %w[name slug]
 
     def self.ransackable_scopes(_auth_object = nil)
-      %i(with_deleted with_variant_sku_cont)
+      %i(with_discarded with_variant_sku_cont)
     end
 
     # @return [Boolean] true if there are any variants
@@ -174,11 +168,22 @@ module Spree
     end
 
     # Determines if product is available. A product is available if it has not
-    # been deleted and the available_on date is in the past.
+    # been deleted, the available_on date is in the past
+    # and the discontinue_on date is nil or in the future.
     #
     # @return [Boolean] true if this product is available
     def available?
-      !(available_on.nil? || available_on.future?) && !deleted?
+      !deleted? && available_on&.past? && !discontinued?
+    end
+
+    # Determines if product is discontinued.
+    #
+    # A product is discontinued if the discontinue_on date
+    # is not nil and in the past.
+    #
+    # @return [Boolean] true if this product is discontinued
+    def discontinued?
+      !!discontinue_on&.past?
     end
 
     # Groups variants by the specified option type.
@@ -190,7 +195,7 @@ module Spree
     # @return [Hash] option_type as keys, array of variants as values.
     def categorise_variants_from_option(opt_type, pricing_options = Spree::Config.default_pricing_options)
       return {} unless option_types.include?(opt_type)
-      variants.with_prices(pricing_options).group_by { |v| v.option_values.detect { |o| o.option_type == opt_type } }
+      variants.with_prices(pricing_options).group_by { |variant| variant.option_values.detect { |option| option.option_type == opt_type } }
     end
     deprecate :categorise_variants_from_option, deprecator: Spree::Deprecation
 
@@ -323,7 +328,7 @@ module Spree
 
     def any_variants_not_track_inventory?
       if variants_including_master.loaded?
-        variants_including_master.any? { |v| !v.should_track_inventory? }
+        variants_including_master.any? { |variant| !variant.should_track_inventory? }
       else
         !Spree::Config.track_inventory_levels || variants_including_master.where(track_inventory: false).exists?
       end
@@ -381,11 +386,11 @@ module Spree
 
     # Iterate through this product's taxons and taxonomies and touch their timestamps in a batch
     def touch_taxons
-      taxons_to_touch = taxons.map(&:self_and_ancestors).flatten.uniq
+      taxons_to_touch = taxons.flat_map(&:self_and_ancestors).uniq
       unless taxons_to_touch.empty?
         Spree::Taxon.where(id: taxons_to_touch.map(&:id)).update_all(updated_at: Time.current)
 
-        taxonomy_ids_to_touch = taxons_to_touch.map(&:taxonomy_id).flatten.uniq
+        taxonomy_ids_to_touch = taxons_to_touch.flat_map(&:taxonomy_id).uniq
         Spree::Taxonomy.where(id: taxonomy_ids_to_touch).update_all(updated_at: Time.current)
       end
     end

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

@@ -2,159 +2,164 @@
 
 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).select('spree_products.* , spree_prices.amount')
+                                         .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).select('spree_products.* , spree_prices.amount')
+                                         .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 +173,101 @@ 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)
+              .where("#{Spree::Product.quoted_table_name}.discontinue_on IS NULL OR" \
+                     "#{Spree::Product.quoted_table_name}.discontinue_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.flat_map { |taxon| taxon.self_and_descendants.pluck(:id) }.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?
+
+              splitted = words.split(/[,\s]/).map(&:strip)
+              splitted.any? ? splitted : ['']
+            end
+
+            def get_taxons(*ids_or_records_or_names)
+              taxons = Spree::Taxon.table_name
+              ids_or_records_or_names.flatten.map { |taxon|
+                case taxon
+                when Integer then Spree::Taxon.find_by(id: taxon)
+                when ActiveRecord::Base then taxon
+                when String
+                  Spree::Taxon.find_by(name: taxon) ||
+                    Spree::Taxon.where("#{taxons}.permalink LIKE ? OR #{taxons}.permalink = ?", "%/#{taxon}/", "#{taxon}/").first
+                end
+              }.compact.flatten.uniq
+            end
           end
-        }.compact.flatten.uniq
+        end
       end
+
+      ::Spree::Product.prepend self
     end
   end
 end