spree_core 5.4.0.beta → 5.4.0.beta2

data/db/migrate/20250305121657_remove_spree_posts_indices.rb

@@ -1,7 +0,0 @@
-class RemoveSpreePostsIndices < ActiveRecord::Migration[7.2]
-  def change
-    if index_name_exists?(:spree_posts, 'index_spree_posts_on_slug_and_store_id')
-      remove_index :spree_posts, name: 'index_spree_posts_on_slug_and_store_id'
-    end
-  end
-end

data/db/migrate/20250730154601_add_unique_index_on_spree_properties_name.rb

@@ -1,24 +0,0 @@
-class AddUniqueIndexOnSpreePropertiesName < ActiveRecord::Migration[7.2]
-  def change
-    # we don't need to run this migration in multi-tenant mode as it's already handled there
-    return if defined?(SpreeMultiTenant)
-
-    # Rename duplicated properties
-    duplicates = Spree::Property.select(:name).group(:name).having('COUNT(*) > 1').reorder('').pluck(:name)
-
-    duplicates.each do |duplicate_name|
-      properties = Spree::Property.where(name: duplicate_name)
-
-      properties.each_with_index do |property, index|
-        next if index == 0 # Keep the first one unchanged
-
-        new_name = "#{duplicate_name}_#{index}"
-        property.update_columns(name: new_name, updated_at: Time.current)
-      end
-    end
-
-    # Add indexes
-    remove_index :spree_properties, :name, if_exists: true
-    add_index :spree_properties, :name, unique: true, if_not_exists: true
-  end
-end

data/db/sample_data/posts.rb

@@ -1,7 +0,0 @@
-store = Spree::Store.default
-
-store.posts.where(title: 'Hello World').first_or_create!(
-  content: 'This is a test post',
-  published_at: Time.current,
-  author: Spree.admin_user_class.first
-)

data/lib/spree/core/controller_helpers/search.rb

@@ -1,17 +0,0 @@
-module Spree
-  module Core
-    module ControllerHelpers
-      module Search
-        def build_searcher(params)
-          Spree::Deprecation.warn("Spree::Core::ControllerHelpers::Search is deprecated and will be removed in Spree 5.5.")
-
-          Spree.searcher_class.new(params).tap do |searcher|
-            searcher.current_user = try_spree_current_user
-            searcher.current_currency = current_currency&.upcase
-            searcher.current_store = current_store
-          end
-        end
-      end
-    end
-  end
-end

data/lib/spree/core/product_filters.rb

@@ -1,218 +0,0 @@
-module Spree
-  module Core
-    # THIS FILE SHOULD BE OVER-RIDDEN IN YOUR SITE EXTENSION!
-    #   the exact code probably won't be useful, though you're welcome to modify and reuse
-    #   the current contents are mainly for testing and documentation
-
-    # To override this file...
-    #   1) Make a copy of it in your sites local /lib/spree folder
-    #   2) Add it to the config load path, or require it in an initializer, e.g...
-    #
-    #      # config/initializers/spree.rb
-    #      require 'spree/core/product_filters'
-    #
-
-    # set up some basic filters for use with products
-    #
-    # Each filter has two parts
-    #  * a parametrized named scope which expects a list of labels
-    #  * an object which describes/defines the filter
-    #
-    # The filter description has three components
-    #  * a name, for displaying on pages
-    #  * a named scope which will 'execute' the filter
-    #  * a mapping of presentation labels to the relevant condition (in the context of the named scope)
-    #  * an optional list of labels and values (for use with object selection - see taxons examples below)
-    #
-    # The named scopes here have a suffix '_any', following Ransack's convention for a
-    # scope which returns results which match any of the inputs. This is purely a convention,
-    # but might be a useful reminder.
-    #
-    # When creating a form, the name of the checkbox group for a filter F should be
-    # the name of F's scope with [] appended, eg "price_range_any[]", and for
-    # each label you should have a checkbox with the label as its value. On submission,
-    # Rails will send the action a hash containing (among other things) an array named
-    # after the scope whose values are the active labels.
-    #
-    # Ransack will then convert this array to a call to the named scope with the array
-    # contents, and the named scope will build a query with the disjunction of the conditions
-    # relating to the labels, all relative to the scope's context.
-    #
-    # The details of how/when filters are used is a detail for specific models (eg products
-    # or taxons), eg see the taxon model/controller.
-
-    # See specific filters below for concrete examples.
-    # @deprecated This module is deprecated and will be removed in Spree 5.5.
-    #   Use Spree::Api::V3::FiltersAggregator instead.
-    module ProductFilters
-      def self.deprecated_warning
-        Spree::Deprecation.warn(
-          'Spree::Core::ProductFilters is deprecated and will be removed in Spree 5.5. ' \
-          'Please use Spree::Api::V3::FiltersAggregator instead.'
-        )
-      end
-
-      # Example: filtering by price
-      #   The named scope just maps incoming labels onto their conditions, and builds the conjunction
-      #   'price' is in the base scope's context (ie, "select foo from products where ...") so
-      #     we can access the field right away
-      #   The filter identifies which scope to use, then sets the conditions for each price range
-      #
-      # If user checks off three different price ranges then the argument passed to
-      # below scope would be something like ["$10 - $15", "$15 - $18", "$18 - $20"]
-      #
-      Spree::Product.add_search_scope :price_range_any do |*opts|
-        conds = opts.map { |o| Spree::Core::ProductFilters.price_filter[:conds][o] }.reject(&:nil?)
-        scope = conds.shift
-        conds.each do |new_scope|
-          scope = scope.or(new_scope)
-        end
-        Spree::Product.joins(master: :default_price).where(scope)
-      end
-
-      def self.format_price(amount)
-        Spree::Money.new(amount)
-      end
-
-      def self.price_filter
-        deprecated_warning
-        v = Spree::Price.arel_table
-        conds = [[Spree.t(:under_price, price: format_price(10)), v[:amount].lteq(10)],
-                 ["#{format_price(10)} - #{format_price(15)}", v[:amount].between(10..15)],
-                 ["#{format_price(15)} - #{format_price(18)}", v[:amount].between(15..18)],
-                 ["#{format_price(18)} - #{format_price(20)}", v[:amount].between(18..20)],
-                 [Spree.t(:or_over_price, price: format_price(20)), v[:amount].gteq(20)]]
-        {
-          name: Spree.t(:price_range),
-          scope: :price_range_any,
-          conds: Hash[*conds.flatten],
-          labels: conds.map { |k, _v| [k, k] }
-        }
-      end
-
-      # Example: filtering by possible brands
-      #
-      # First, we define the scope. Two interesting points here: (a) we run our conditions
-      #   in the scope where the info for the 'brand' property has been loaded; and (b)
-      #   because we may want to filter by other properties too, we give this part of the
-      #   query a unique name (which must be used in the associated conditions too).
-      #
-      # Secondly, the filter. Instead of a static list of values, we pull out all existing
-      #   brands from the db, and then build conditions which test for string equality on
-      #   the (uniquely named) field "p_brand.value". There's also a test for brand info
-      #   being blank: note that this relies on with_property doing a left outer join
-      #   rather than an inner join.
-      Spree::Product.add_search_scope :brand_any do |*opts|
-        conds = opts.map { |o| ProductFilters.brand_filter[:conds][o] }.reject(&:nil?)
-        scope = conds.shift
-        conds.each do |new_scope|
-          scope = scope.or(new_scope)
-        end
-
-        if Spree.use_translations?
-          Product.with_property('brand').join_translation_table(ProductProperty).where(scope)
-        else
-          Product.with_property('brand').where(scope)
-        end
-      end
-
-      def self.brand_filter
-        deprecated_warning
-        brand_property = Spree::Property.find_by(name: 'brand')
-        brands = brand_property ? Spree::ProductProperty.where(property_id: brand_property.id).pluck(:value).uniq.map(&:to_s) : []
-
-        conditions = brands.map do |brand|
-          table_name = Spree.use_translations? ? ProductProperty.translation_table_alias : ProductProperty.table_name
-
-          [brand, { table_name.to_s => { value: brand } }]
-        end.to_h
-
-        {
-          name: I18n.t('spree.taxonomy_brands_name'),
-          scope: :brand_any,
-          conds: conditions,
-          labels: brands.sort.map { |k| [k, k] }
-        }
-      end
-
-      # Example: a parameterized filter
-      #   The filter above may show brands which aren't applicable to the current taxon,
-      #   so this one only shows the brands that are relevant to a particular taxon and
-      #   its descendants.
-      #
-      #   We don't have to give a new scope since the conditions here are a subset of the
-      #   more general filter, so decoding will still work - as long as the filters on a
-      #   page all have unique names (ie, you can't use the two brand filters together
-      #   if they use the same scope). To be safe, the code uses a copy of the scope.
-      #
-      #   HOWEVER: what happens if we want a more precise scope?  we can't pass
-      #   parametrized scope names to Ransack, only atomic names, so couldn't ask
-      #   for taxon T's customized filter to be used. BUT: we can arrange for the form
-      #   to pass back a hash instead of an array, where the key acts as the (taxon)
-      #   parameter and value is its label array, and then get a modified named scope
-      #   to get its conditions from a particular filter.
-      #
-      #   The brand-finding code can be simplified if a few more named scopes were added to
-      #   the product properties model.
-      Spree::Product.add_search_scope :selective_brand_any do |*opts|
-        Spree::Product.brand_any(*opts)
-      end
-
-      def self.selective_brand_filter(taxon = nil)
-        deprecated_warning
-        taxon ||= Spree::Taxonomy.first.root
-        brand_property = Spree::Property.find_by(name: 'brand')
-        scope = Spree::ProductProperty.where(property: brand_property).
-                joins(product: :taxons).
-                where("#{Spree::Taxon.table_name}.id" => [taxon] + taxon.descendants)
-        brands = scope.pluck(:value).uniq
-        {
-          name: 'Applicable Brands',
-          scope: :selective_brand_any,
-          labels: brands.sort.map { |k| [k, k] }
-        }
-      end
-
-      # Provide filtering on the immediate children of a taxon
-      #
-      # This doesn't fit the pattern of the examples above, so there's a few changes.
-      # Firstly, it uses an existing scope which was not built for filtering - and so
-      # has no need of a conditions mapping, and secondly, it has a mapping of name
-      # to the argument type expected by the other scope.
-      #
-      # This technique is useful for filtering on objects (by passing ids) or with a
-      # scope that can be used directly (eg. testing only ever on a single property).
-      #
-      # This scope selects products in any of the active taxons or their children.
-      #
-      def self.taxons_below(taxon)
-        deprecated_warning
-        return Spree::Core::ProductFilters.all_taxons if taxon.nil?
-
-        {
-          name: 'Taxons under ' + taxon.name,
-          scope: :taxons_id_in_tree_any,
-          labels: taxon.children.sort_by(&:position).map { |t| [t.name, t.id] },
-          conds: nil
-        }
-      end
-
-      # Filtering by the list of all taxons
-      #
-      # Similar idea as above, but we don't want the descendants' products, hence
-      # it uses one of the auto-generated scopes from Ransack.
-      #
-      # idea: expand the format to allow nesting of labels?
-      def self.all_taxons
-        deprecated_warning
-        taxons = Spree::Taxonomy.all.map { |t| [t.root] + t.root.descendants }.flatten
-        {
-          name: 'All taxons',
-          scope: :taxons_id_equals_any,
-          labels: taxons.sort_by(&:name).map { |t| [t.name, t.id] },
-          conds: nil # not needed
-        }
-      end
-    end
-  end
-end

data/lib/spree/core/query_filters/comparable.rb

@@ -1,50 +0,0 @@
-module Spree
-  module Core
-    module QueryFilters
-      # @deprecated This class is deprecated and will be removed in Spree 5.5.
-      class Comparable
-        def initialize(attribute:)
-          Spree::Deprecation.warn(
-            "#{self.class.name} is deprecated and will be removed in Spree 5.5."
-          )
-          @attribute = attribute
-        end
-
-        def call(scope:, filter:)
-          scope = gt(scope, filter[:gt])
-          scope = gteq(scope, filter[:gteq])
-          scope = lt(scope, filter[:lt])
-          lteq(scope, filter[:lteq])
-        end
-
-        private
-
-        attr_reader :attribute
-
-        def gt(scope, value)
-          return scope unless value
-
-          scope.where(attribute.gt(value))
-        end
-
-        def gteq(scope, value)
-          return scope unless value
-
-          scope.where(attribute.gteq(value))
-        end
-
-        def lt(scope, value)
-          return scope unless value
-
-          scope.where(attribute.lt(value))
-        end
-
-        def lteq(scope, value)
-          return scope unless value
-
-          scope.where(attribute.lteq(value))
-        end
-      end
-    end
-  end
-end

data/lib/spree/core/query_filters/date.rb

@@ -1,8 +0,0 @@
-module Spree
-  module Core
-    module QueryFilters
-      class Date < Comparable
-      end
-    end
-  end
-end

data/lib/spree/core/query_filters/number.rb

@@ -1,8 +0,0 @@
-module Spree
-  module Core
-    module QueryFilters
-      class Number < Comparable
-      end
-    end
-  end
-end

data/lib/spree/core/query_filters/text.rb

@@ -1,36 +0,0 @@
-module Spree
-  module Core
-    module QueryFilters
-      # @deprecated This class is deprecated and will be removed in Spree 5.5.
-      class Text
-        def initialize(attribute:)
-          Spree::Deprecation.warn(
-            'Spree::Core::QueryFilters::Text is deprecated and will be removed in Spree 5.5.'
-          )
-          @attribute = attribute
-        end
-
-        def call(scope:, filter:)
-          scope = eq(scope, filter[:eq])
-          contains(scope, filter[:contains])
-        end
-
-        private
-
-        attr_reader :attribute
-
-        def eq(scope, value)
-          return scope unless value
-
-          scope.where(attribute.eq(value))
-        end
-
-        def contains(scope, value)
-          return scope unless value
-
-          scope.where(attribute.matches("%#{value}%"))
-        end
-      end
-    end
-  end
-end

data/lib/spree/core/query_filters.rb

@@ -1,11 +0,0 @@
-module Spree
-  module Core
-    module QueryFilters
-    end
-  end
-end
-
-require 'spree/core/query_filters/comparable'
-require 'spree/core/query_filters/number'
-require 'spree/core/query_filters/date'
-require 'spree/core/query_filters/text'

data/lib/spree/core/search/base.rb

@@ -1,144 +0,0 @@
-module Spree
-  module Core
-    module Search
-      class Base
-        attr_accessor :properties, :current_user, :current_currency, :current_store, :taxon
-
-        def initialize(params)
-          Spree::Deprecation.warn("Spree::Core::Search::Base is deprecated and will be removed in Spree 5.5. Please use `Spree::Products::Find` finder instead.")
-
-          @properties = {}
-          @current_store = params[:current_store] || Spree::Store.default
-          @current_currency = @current_store.default_currency
-          @taxon = params[:taxon]
-
-          prepare(params)
-        end
-
-        def retrieve_products
-          @products = extended_base_scope.page(page || 1).per(per_page)
-        end
-
-        def method_missing(name)
-          if @properties.key? name
-            @properties[name]
-          else
-            super
-          end
-        end
-
-        protected
-
-        def extended_base_scope
-          base_scope = current_store.products.spree_base_scopes
-          base_scope = get_products_conditions_for(base_scope, keywords)
-          base_scope = Spree.products_finder.new(**product_finder_params(base_scope)).execute
-          base_scope = add_search_scopes(base_scope)
-          add_eagerload_scopes(base_scope)
-        end
-
-        def product_finder_params(base_scope)
-          {
-            scope: base_scope,
-            params: {
-              store: current_store,
-              filter: {
-                price: price,
-                option_value_ids: option_value_ids,
-                properties: product_properties,
-                taxons: taxon&.id,
-                currency: current_currency
-              },
-              sort_by: sort_by
-            }
-          }
-        end
-
-        def add_eagerload_scopes(scope)
-          scope.includes(
-            :tax_category,
-            variants: [
-              { images: { attachment_attachment: :blob } }
-            ],
-            master: [
-              :prices,
-              { images: { attachment_attachment: :blob } }
-            ]
-          )
-        end
-
-        def add_search_scopes(base_scope)
-          if search.is_a?(ActionController::Parameters)
-            search.each do |name, scope_attribute|
-              scope_name = name.to_sym
-
-              base_scope = if base_scope.respond_to?(:search_scopes) && base_scope.search_scopes.include?(scope_name.to_sym)
-                             base_scope.send(scope_name, *scope_attribute)
-                           else
-                             base_scope.merge(Spree::Product.ransack(scope_name => scope_attribute).result)
-                           end
-            end
-          end
-          base_scope
-        end
-
-        # method should return new scope based on base_scope
-        def get_products_conditions_for(base_scope, query)
-          unless query.blank?
-            base_scope = base_scope.i18n { name.matches("%#{query}%").or(description.matches("%#{query}%")) }
-          end
-          base_scope
-        end
-
-        def get_products_option_values_conditions(base_scope, option_value_ids)
-          unless option_value_ids.blank?
-            base_scope = base_scope.joins(variants: :option_values).where(spree_option_values: { id: option_value_ids })
-          end
-          base_scope
-        end
-
-        def get_price_range(price_param)
-          return if price_param.blank?
-
-          less_than_string = I18n.t('activerecord.attributes.spree/product.less_than')
-
-          if price_param.include? less_than_string
-            low_price = 0
-            high_price = Monetize.parse(price_param.remove("#{less_than_string} ")).to_i
-          else
-            low_price, high_price = Monetize.parse_collection(price_param).map(&:to_i)
-            high_price = BigDecimal::INFINITY if high_price&.zero?
-          end
-
-          "#{low_price},#{high_price}"
-        end
-
-        def build_option_value_ids(params)
-          filter_params = Spree::OptionType.filterable.map(&:filter_param)
-
-          filter_params.reduce([]) do |acc, filter_param|
-            acc + params[filter_param].to_s.split(',')
-          end
-        end
-
-        def prepare(params)
-          @properties[:keywords] = params[:keywords]
-          @properties[:option_value_ids] = build_option_value_ids(params)
-          @properties[:price] = get_price_range(params[:price])
-          @properties[:search] = params[:search]
-          @properties[:sort_by] = params[:sort_by] || 'default'
-          @properties[:include_images] = params[:include_images]
-
-          per_page = params[:per_page].to_i
-          @properties[:per_page] = per_page > 0 ? per_page : Spree::Config[:products_per_page]
-          @properties[:page] = if params[:page].respond_to?(:to_i)
-                                 params[:page].to_i <= 0 ? 1 : params[:page].to_i
-                               else
-                                 1
-                               end
-          @properties[:product_properties] = params[:properties]
-        end
-      end
-    end
-  end
-end

data/lib/spree/testing_support/factories/favicon_image_factory.rb

@@ -1,9 +0,0 @@
-FactoryBot.define do
-  factory :favicon_image, class: Spree::StoreFaviconImage do
-    transient do
-      filepath { Spree::Core::Engine.root.join('spec', 'fixtures', 'favicon.ico') }
-    end
-
-    attachment { Rack::Test::UploadedFile.new(filepath) }
-  end
-end

data/lib/spree/testing_support/factories/google_data_feed_factory.rb

@@ -1,7 +0,0 @@
-FactoryBot.define do
-  factory :google_data_feed, class: Spree::DataFeed::Google do
-    active         { true }
-    association :store, factory: :store
-    name           { 'test' }
-  end
-end

data/lib/spree/testing_support/factories/post_category_factory.rb

@@ -1,7 +0,0 @@
-FactoryBot.define do
-  factory :post_category, class: Spree::PostCategory do
-    sequence(:title) { |n| "Category ##{n + 1}" }
-    description { FFaker::Lorem.sentence }
-    store { Spree::Store.default || create(:store) }
-  end
-end

data/lib/spree/testing_support/factories/post_factory.rb

@@ -1,22 +0,0 @@
-FactoryBot.define do
-  factory :post, class: Spree::Post do
-    store { Spree::Store.default || create(:store) }
-    post_category { association(:post_category, store: store) }
-    title { FFaker::Lorem.sentence }
-    content { FFaker::Lorem.paragraph }
-    published_at { Time.current }
-    association :author, factory: :admin_user
-
-    trait :with_image do
-      image { Rack::Test::UploadedFile.new(Spree::Core::Engine.root.join('spec/fixtures/thinking-cat.jpg'), 'image/jpeg') }
-    end
-
-    trait :published do
-      published_at { Time.current }
-    end
-
-    trait :unpublished do
-      published_at { nil }
-    end
-  end
-end

data/lib/spree/testing_support/factories/product_property_factory.rb

@@ -1,7 +0,0 @@
-FactoryBot.define do
-  factory :product_property, class: Spree::ProductProperty do
-    product
-    value { "val-#{rand(50)}" }
-    property
-  end
-end

data/lib/spree/testing_support/factories/property_factory.rb

@@ -1,28 +0,0 @@
-FactoryBot.define do
-  factory :property, class: Spree::Property do
-    sequence(:name) { |n| "baseball_cap_color_#{n}" }
-    presentation { 'cap color' }
-
-    trait :filterable do
-      filterable { true }
-    end
-
-    trait :brand do
-      name         { 'brand' }
-      presentation { 'Brand' }
-      filter_param { 'brand' }
-    end
-
-    trait :manufacturer do
-      name         { 'manufacturer' }
-      presentation { 'Manufacturer' }
-      filter_param { 'manufacturer' }
-    end
-
-    trait :material do
-      name         { 'material' }
-      presentation { 'Material' }
-      filter_param { 'material' }
-    end
-  end
-end

data/lib/spree/testing_support/factories/taxon_image_factory.rb

@@ -1,9 +0,0 @@
-FactoryBot.define do
-  factory :taxon_image, class: Spree::TaxonImage do
-    before(:create) do |taxon_image|
-      if taxon_image.class.method_defined?(:attachment)
-        taxon_image.attachment.attach(io: File.new(Spree::Core::Engine.root + 'spec/fixtures/thinking-cat.jpg'), filename: 'thinking-cat.jpg')
-      end
-    end
-  end
-end

data/lib/spree/testing_support/flash.rb

@@ -1,25 +0,0 @@
-module Spree
-  module TestingSupport
-    module Flash
-      def assert_flash_success(flash)
-        flash = convert_flash(flash)
-
-        within("[class='flash success']") do
-          expect(page).to have_content(flash)
-        end
-      end
-
-      def assert_successful_update_message(resource)
-        flash = Spree.t(:successfully_updated, resource: Spree.t(resource))
-        assert_flash_success(flash)
-      end
-
-      private
-
-      def convert_flash(flash)
-        flash = Spree.t(flash) if flash.is_a?(Symbol)
-        flash
-      end
-    end
-  end
-end