spree_storefront 5.0.0.rc1

data/app/helpers/spree/filters_helper.rb

@@ -0,0 +1,180 @@
+module Spree
+  module FiltersHelper
+    def products_for_filters_default_scope
+      scope = storefront_products_scope
+      scope = scope.in_taxon(@taxon) if @taxon.present?
+      scope = scope.search_by_name(params[:q].strip).unscope(:order) if params[:q].present?
+      scope
+    end
+
+    def products_for_filters_scope(except_filters: [])
+      products_finder = Spree::Dependencies.products_finder.constantize
+
+      finder_params = default_products_finder_params
+      finder_params[:filter] = finder_params[:filter].except(*except_filters) if except_filters.any?
+
+      products = products_finder.new(scope: storefront_products_scope, params: finder_params).execute
+      current_store.products.where(id: products.unscope(:order).ids)
+    end
+
+    def storefront_products_for_filters
+      @storefront_products_for_filters ||= products_for_filters_scope
+    end
+
+    def default_storefront_products_for_filters
+      @default_storefront_products_for_filters ||= products_for_filters_default_scope.unscope(:order)
+    end
+
+    def product_filters_aggregations
+      @product_filters_aggregations ||= storefront_products_for_filters.
+                                        joins(variants_including_master: :option_values).
+                                        group("#{Spree::OptionValue.table_name}.id").
+                                        distinct.
+                                        count
+    end
+
+    def product_single_filter_aggregations
+      @product_single_filter_aggregations ||= default_storefront_products_for_filters.
+                                              joins(variants_including_master: :option_values).
+                                              group("#{Spree::OptionValue.table_name}.id").
+                                              distinct.
+                                              count
+    end
+
+    def products_count_for_filter(name, value_id)
+      aggregations = single_option_filter_selected?(name) ? product_single_filter_aggregations : product_filters_aggregations
+      aggregations.fetch(value_id, 0)
+    end
+
+    def filter_price_range
+      @filter_price_range ||= begin
+        product_ids = products_for_filters_scope(except_filters: [:price]).ids
+
+        {
+          min: Spree::Price.for_products(product_ids).minimum(:amount) || 0.to_d,
+          max: Spree::Price.for_products(product_ids).maximum(:amount) || 0.to_d
+        }
+      end
+    end
+
+    def filter_stock_count
+      @filter_stock_count ||= begin
+        products_scope = products_for_filters_scope(except_filters: [:purchasable, :out_of_stock])
+
+        {
+          in_stock: products_scope.in_stock.distinct.count,
+          out_of_stock: products_scope.out_of_stock.distinct.count
+        }
+      end
+    end
+
+    def default_storefront_filter_values_scope
+      @default_storefront_filter_values_scope ||= Spree::OptionValue.for_products(products_for_filters_default_scope).distinct
+    end
+
+    def storefront_filter_values_scope(filter_selected)
+      if filter_selected
+        default_storefront_filter_values_scope
+      else
+        Spree::OptionValue.for_products(storefront_products_for_filters).distinct
+      end
+    end
+
+    def filter_values_for_filter(filter)
+      selected = single_option_filter_selected?(filter.name)
+      if filter.option_values.loaded?
+        storefront_filter_values_ids = storefront_filter_values_scope(selected).pluck(:id)
+
+        filter.option_values.find_all { |option_value| storefront_filter_values_ids.include?(option_value.id) }
+      else
+        filter.option_values.where(id: storefront_filter_values_scope(selected))
+      end
+    end
+
+    def storefront_products_for_taxon_filters
+      @storefront_products_for_taxon_filters ||= products_for_filters_scope(except_filters: [:taxons])
+    end
+
+    def filter_taxon_ids
+      @filter_taxon_ids ||= Rails.cache.fetch([spree_base_cache_key, storefront_products_for_taxon_filters, @taxon], expires_in: 1.day) do
+        scope = storefront_products_for_taxon_filters.joins(:classifications)
+        scope = scope.in_taxon(@taxon).unscope(:order) if @taxon.present?
+        scope.distinct.pluck(:taxon_id)
+      end
+    end
+
+    def filter_taxons_for_taxonomy(taxonomy)
+      taxon_depth = @taxon.present? ? @taxon.depth + 1 : 1
+
+      taxonomy.taxons.where(depth: taxon_depth).order(:lft).find_all do |taxon|
+        (taxon.cached_self_and_descendants_ids & filter_taxon_ids).any?
+      end
+    end
+
+    def product_taxon_aggregations
+      @product_taxon_aggregations ||= Rails.cache.fetch([spree_base_cache_key, storefront_products_for_taxon_filters, current_store.taxons], expires_in: 1.day) do
+        current_store.taxons.
+          joins(:classifications).
+          where("#{Spree::Classification.table_name}.product_id" => storefront_products_for_taxon_filters.ids).
+                                      group(
+                                        "#{Spree::Taxon.table_name}.id",
+                                        "#{Spree::Classification.table_name}.product_id"
+                                      ).
+          unscope(:order).
+          count("#{Spree::Classification.table_name}.product_id")
+      end
+    end
+
+    def products_count_for_taxon(taxon)
+      taxon_self_and_descendants_ids = taxon.cached_self_and_descendants_ids
+      aggregations = product_taxon_aggregations.select { |key, _value| key[0].in?(taxon_self_and_descendants_ids) }
+
+      # We want to count unique products across the taxon tree
+      aggregations.uniq { |key, _value| key[1] }.sum(&:last)
+    end
+
+    def filter_form_fields
+      return '' if products_filters_params.blank?
+
+      map_filters_params_to_form_fields(products_filters_params)
+    end
+
+    def map_filters_params_to_form_fields(filters_params, prefix_key = nil)
+      filters_params.to_h.map do |key, value|
+        key = CGI.escapeHTML(key)
+        key = [prefix_key, key].join('][') if prefix_key.present?
+
+        if value.is_a?(Array)
+          value.map do |v|
+            v = CGI.escapeHTML(v)
+            "<input type='hidden' name='filter[#{key}][]' value='#{v}' />"
+          end.join
+        elsif value.is_a?(Hash)
+          map_filters_params_to_form_fields(value, key)
+        else
+          value = CGI.escapeHTML(value)
+          "<input type='hidden' name='filter[#{key}]' value='#{value}' />"
+        end
+      end.join.html_safe
+    end
+
+    def single_option_filter_selected?(filter_name)
+      options_filter = permitted_products_params.dig(:filter, :options) || {}
+
+      !price_filtered? && !taxons_filtered? &&
+        options_filter.keys.length == 1 && options_filter.key?(filter_name)
+    end
+
+    def price_filtered?
+      min_price = permitted_products_params.dig(:filter, :min_price).presence
+      max_price = permitted_products_params.dig(:filter, :max_price).presence
+
+      (min_price.present? && min_price.to_d >= filter_price_range[:min]) ||
+        (max_price.present? && max_price.to_d <= filter_price_range[:max])
+    end
+
+    def taxons_filtered?
+      permitted_products_params.dig(:filter, :taxon_ids)&.any?
+    end
+  end
+end

data/app/helpers/spree/fonts_helper.rb

@@ -0,0 +1,58 @@
+module Spree
+  module FontsHelper
+    def normal_font_family_styles
+      return '' if current_theme_or_preview.preferred_font_family.blank?
+
+      font_family = current_theme_or_preview.preferred_font_family
+      text_font_size = (current_theme_or_preview.preferred_font_size_scale || 100) / 100.0
+
+      <<~CSS
+        :root {
+          --font-body: #{font_family};
+        }
+
+        body {
+          font-family: '#{font_family}', sans-serif;
+        }
+
+        body {
+          font-size: #{text_font_size}rem;
+        }
+      CSS
+    end
+
+    def header_font_family_styles
+      return '' if current_theme_or_preview.preferred_header_font_family.blank?
+
+      font_family = current_theme_or_preview.preferred_header_font_family
+
+      <<~CSS
+        h1, h2, h3, h4, h5, h6 {
+          font-family: '#{font_family}', sans-serif;
+        }
+      CSS
+    end
+
+    def google_fonts_link_tag
+      fonts = [current_theme_or_preview.preferred_font_family, current_theme_or_preview.preferred_header_font_family].compact_blank.uniq
+
+      return if fonts.blank?
+
+      imports = fonts.map do |font|
+        "family=#{font.split(' ').join('+')}:wght@200..700"
+      end.compact.join('&')
+
+      return if imports.blank?
+      return if Rails.env.test?
+
+      stylesheet_link_tag "https://fonts.googleapis.com/css2?#{imports}&display=swap"
+    end
+
+    def font_styles
+      <<~CSS.html_safe
+        #{normal_font_family_styles}
+        #{header_font_family_styles}
+      CSS
+    end
+  end
+end

data/app/helpers/spree/orders_helper.rb

@@ -0,0 +1,7 @@
+module Spree
+  module OrdersHelper
+    def order_just_completed?
+      @order.present? && @order.completed? && session[:checkout_completed].present?
+    end
+  end
+end

data/app/helpers/spree/page_helper.rb

@@ -0,0 +1,67 @@
+module Spree
+  module PageHelper
+    def render_page(page = nil, variables = {})
+      page ||= current_page
+
+      sections = current_page_preview.present? ? current_page_preview.sections : page.sections
+      sections_html = sections.includes(:links, { asset_attachment: :blob }, { blocks: [:rich_text_text, :links] }).map do |section|
+        render_section(section, variables)
+      end.join.html_safe
+
+      "<main class='page-contents'>#{sections_html}</main>".html_safe
+    end
+
+    def render_section(section, variables = {}, lazy_allowed: true)
+      return '' if section.blank?
+
+      variables[:section] = section
+      variables[:loaded] = true
+
+      css_id = "section-#{section.id}"
+      css_class = "section-#{section.class.name.demodulize.underscore.dasherize}"
+
+      if page_builder_enabled?
+        turbo_frame_tag(css_id, class: css_class) do
+          content_tag(:div,
+            data: {
+              editor_id: css_id,
+              editor_name: section.name,
+              editor_link: spree.edit_admin_page_section_path(section)
+            }
+          ) do
+            render('/' + section.to_partial_path, **variables)
+          end
+        end
+      elsif section.lazy? && lazy_allowed
+        variables[:loaded] = false
+        variables[:url_options] = { locale: I18n.locale }
+
+        path = section.lazy_path(variables)
+
+        turbo_frame_tag(css_id, src: path, loading: 'eager', class: css_class) do
+          render('/' + section.to_partial_path, **variables)
+        end
+      else
+        content_tag(:div, id: css_id, class: css_class) do
+          render('/' + section.to_partial_path, **variables)
+        end
+      end
+    rescue ActionView::MissingTemplate, ActionView::Template::Error => e
+      raise e unless Rails.env.production?
+
+      Rails.error.report(e, context: { section_id: section.id }, source: 'spree.storefront')
+
+      ''
+    end
+
+    def page_builder_link_to(link, options = {}, &block)
+      if link.present?
+        link_to(spree_storefront_resource_url(link.linkable || link), options.except(:label)) do
+          block.present? ? block.call : options[:label]
+        end
+      else
+        block&.call&.html_safe
+      end
+    end
+  end
+end

data/app/helpers/spree/posts_helper.rb

@@ -0,0 +1,42 @@
+module Spree
+  module PostsHelper
+    def posts_json_ld_breadcrumbs(post)
+      json_ld = {
+        '@context' => 'https://schema.org',
+        '@type' => 'BreadcrumbList',
+        'itemListElement' => [
+          {
+            '@type' => 'ListItem',
+            'position' => 1,
+            'name' => Spree.t(:homepage),
+            'item' => spree.root_url(host: current_store.url_or_custom_domain)
+          },
+          {
+            '@type' => 'ListItem',
+            'position' => 2,
+            'name' => Spree.t(:blog),
+            'item' => spree.posts_url(host: current_store.url_or_custom_domain)
+          }
+        ]
+      }
+
+      post_breadcrumb = { '@type' => 'ListItem', 'name' => post.title }
+      post_category = post.post_category
+
+      if post_category.present?
+        json_ld['itemListElement'] << {
+          '@type' => 'ListItem',
+          'position' => 3,
+          'name' => post_category.title,
+          'item' => spree.category_posts_url(category_id: post.post_category.slug, host: current_store.url_or_custom_domain)
+        }
+
+        json_ld['itemListElement'] << post_breadcrumb.merge('position' => 4)
+      else
+        json_ld['itemListElement'] << post_breadcrumb.merge('position' => 3)
+      end
+
+      json_ld
+    end
+  end
+end

data/app/helpers/spree/products_helper.rb

@@ -0,0 +1,205 @@
+module Spree
+  module ProductsHelper
+    include BaseHelper
+
+    def product_cache_key(product)
+      [
+        current_theme,
+        current_store,
+        try_spree_current_user,
+        current_currency,
+        I18n.locale,
+        product.cache_key_with_version,
+        product.available?,
+        product.discontinued?,
+      ]
+    end
+
+    def should_display_compare_at_price?(product_or_variant)
+      price = product_or_variant.price_in(current_currency)
+      price.compare_at_amount.present? && (price.compare_at_amount > price.amount)
+    end
+
+    def weeks_online(product)
+      (Time.current - product.activated_at.in_time_zone(current_store.preferred_timezone)).seconds.in_weeks.to_i.abs
+    end
+
+    def brand_name(product)
+      product.brand&.name || product.vendor&.display_name
+    end
+
+    def product_not_selected_options(product, selected_variant, options_param_name: :options)
+      product.option_types.map do |option_type|
+        if product_selected_option_for_option(
+          option_type,
+          product: product,
+          selected_variant: selected_variant,
+          options_param_name: options_param_name
+        ).present?
+          next
+        else
+          option_type
+        end
+      end.compact_blank
+    end
+
+    def product_selected_option_for_option(option_type, product:, selected_variant: nil, options_param_name: :options)
+      @memoized_values ||= {}
+      memoized_key = "#{product.id}-#{selected_variant&.id}-#{option_type.id}-#{options_param_name}"
+
+      product_selected_options_hash = if params[options_param_name].present?
+                                        params[options_param_name].split(',').to_h do |option|
+                                          key, *value = option.split(':')
+                                          [key, value.join(':')]
+                                        end
+                                      else
+                                        {}
+                                      end
+
+      @memoized_values[memoized_key] ||=
+        if selected_variant.present?
+          selected_variant.option_values.find { |ov| ov.option_type_id == option_type.id }
+        elsif product_selected_options_hash.present? && product_selected_options_hash[option_type.id.to_s].present? # user selected variant which is not available
+          option_type.option_values.find { |v| v.name == product_selected_options_hash[option_type.id.to_s] }
+        elsif option_type.color? && (available_variant = product.first_available_variant(current_currency))
+          available_variant.option_values.find { |ov| ov.option_type_id == option_type.id }
+        elsif option_type.color? && product.first_available_variant(current_currency).nil?
+          product.variants.first&.option_values&.find { |ov| ov.option_type_id == option_type.id }
+        end
+    end
+
+    def product_option_values_for_option(option_type, product:)
+      product.option_values.includes(:option_type).
+        find_all { |option_value| option_value.option_type_id == option_type.id }.
+        uniq { |ov| [ov.name, ov.option_type&.name] }
+    end
+
+    def product_media_gallery_images(product, selected_variant:, variant_from_options:, options_param_name: :options)
+      images = selected_variant&.images&.to_a || []
+      images ||= variant_from_options&.images&.to_a if images.empty?
+
+      if images.compact.empty?
+        first_option_type = product.option_types.first
+
+        if first_option_type.present?
+          variant_for_first_option = product_variant_for_selected_option(
+            first_option_type, product: product, selected_variant: selected_variant, options_param_name: options_param_name
+          )
+
+          images << variant_for_first_option.images.to_a if variant_for_first_option.present?
+        end
+      end
+
+      images << product.master&.images&.to_a
+      images << product.default_image if images.flatten.compact.empty?
+
+      images.flatten.compact.uniq(&:id)
+    end
+
+    def variant_featured_image(variant)
+      return nil unless variant
+
+      variant.images.first
+    end
+
+    def image_alt(image)
+      @memoized_image_alts ||= {}
+      key = image.id
+
+      @memoized_image_alts[key] ||=
+        image.alt.presence ||
+        (image.viewable.descriptive_name if image.viewable_type == 'Spree::Variant') ||
+        @product.name
+    end
+
+    def product_variant_for_selected_option(option_type, product:, selected_variant:, options_param_name: :options)
+      selected_value_for_option = product_selected_option_for_option(
+        option_type,
+        product: product,
+        selected_variant: selected_variant,
+        options_param_name: options_param_name
+      )
+      return unless selected_value_for_option.present?
+
+      product.variants.with_option_value(option_type.name, selected_value_for_option.name).first
+    end
+
+    def products_selected_filters_count
+      params[:filters].present? ? params[:filters].split(',').count : 0
+    end
+
+    def products_sort
+      @products_sort ||= permitted_products_params[:sort_by]&.strip_html_tags.presence || default_products_sort
+    end
+
+    def taxons_sort_options
+      @taxons_sort_options ||= [
+        { name: Spree.t('products_sort_options.relevance'), value: 'manual' },
+        { name: Spree.t('products_sort_options.best_selling'), value: 'best-selling' },
+        { name: Spree.t('products_sort_options.name_a_z'), value: 'name-a-z' },
+        { name: Spree.t('products_sort_options.name_z_a'), value: 'name-z-a' },
+        { name: Spree.t('products_sort_options.price_low_to_high'), value: 'price-low-to-high' },
+        { name: Spree.t('products_sort_options.price_high_to_low'), value: 'price-high-to-low' },
+        { name: Spree.t('products_sort_options.newest_first'), value: 'newest-first' },
+        { name: Spree.t('products_sort_options.oldest_first'), value: 'oldest-first' }
+      ]
+    end
+
+    def product_breadcrumb_taxons(product)
+      return Spree::Taxon.none if product.main_taxon.blank?
+
+      # using find_all as we already iterate over the taxons in #product_json_ld_breadcrumbs
+      product.main_taxon.self_and_ancestors.find_all { |taxon| taxon.depth != 0 }
+    end
+
+    def product_list_json_ld_elements(product_slugs)
+      product_slugs.each_with_index.map do |product_slug, index|
+        {
+          '@type' => 'ListItem',
+          'position' => index + 1,
+          'url' => spree.product_url(product_slug)
+        }
+      end
+    end
+
+    def product_json_ld_breadcrumbs(product)
+      json_ld = {
+        '@context' => 'https://schema.org',
+        '@type' => 'BreadcrumbList',
+        'itemListElement' => [
+          {
+            '@type': 'ListItem',
+            'position' => 1,
+            'name' => 'Homepage',
+            'item' => spree.root_url(host: current_store.url_or_custom_domain)
+          }
+        ]
+      }
+
+      if product.main_taxon.present?
+        product.main_taxon.self_and_ancestors.each_with_index do |taxon, index|
+          json_ld['itemListElement'] << {
+            '@type' => 'ListItem',
+            'position' => index + 2,
+            'name' => taxon.name,
+            'item' => spree.nested_taxons_url(taxon, host: current_store.url_or_custom_domain)
+          }
+        end
+      end
+
+      json_ld['itemListElement'] << {
+        '@type' => 'ListItem',
+        'position' => json_ld['itemListElement'].length + 1,
+        'name' => product.name
+      }
+
+      json_ld
+    end
+
+    def option_type_colors_preview_styles(option_type)
+      return unless option_type.color?
+
+      Spree::ColorsPreviewStylesPresenter.new(option_type.option_values.map { |ov| { name: ov.name, filter_name: ov.name } }).to_s
+    end
+  end
+end

data/app/helpers/spree/storefront_helper.rb

@@ -0,0 +1,86 @@
+module Spree
+  module StorefrontHelper
+    include BaseHelper
+    include Heroicon::Engine.helpers
+
+    def render_storefront_partials(section)
+      Rails.application.config.spree_storefront.send(section).map do |partial|
+        render partial: partial
+      end.join.html_safe
+    end
+
+    def page_description
+      return @page_description if @page_description.present?
+
+      @page_description = object.meta_description if object.respond_to?(:meta_description)
+
+      if @page_description.blank? && [Spree::Product, Spree::Taxon, Spree::Post].include?(object.class)
+        @page_description = truncate(strip_tags(object.description.to_s).strip, length: 160, separator: ' ', escape: false)
+      end
+
+      @page_description = current_store.meta_description if @page_description.blank?
+
+      @page_description
+    end
+
+    def page_image
+      return @page_image if @page_image.present?
+
+      if object.is_a? Spree::Product
+        @page_image = object.default_image&.attachment
+      elsif object.respond_to?(:image)
+        @page_image = object.image
+      end
+
+      @page_image ||= current_store.social_image
+
+      @page_image
+    end
+
+    def tailwind_classes_for(flash_type)
+      {
+        notice: 'alert-notice',
+        success: 'alert-success',
+        error: 'alert-error',
+        alert: 'alert-warning',
+      }.stringify_keys[flash_type.to_s] || flash_type.to_s
+    end
+
+    def as_aspect_ratio(attachment)
+      return unless attachment.present?
+      return unless attachment.analyzed?
+
+      metadata = attachment.metadata
+      aspect_ratio = metadata['aspect_ratio'].presence
+
+      return aspect_ratio if aspect_ratio
+
+      width = metadata['width']&.to_f
+      return unless width
+
+      height = metadata['height']&.to_f
+      return unless height
+
+      width / height
+    end
+
+    def svg_country_icon(country_code)
+      country_code = :us if country_code.to_s.downcase == 'en'
+      tag.span(class: "fi fi-#{country_code.downcase}")
+    end
+
+    def show_account_pane?
+      !try_spree_current_user &&
+        (defined?(spree_login_path) && !paths_equal?(canonical_path, spree_login_path)) &&
+        (defined?(spree_signup_path) && !paths_equal?(canonical_path, spree_signup_path)) &&
+        (defined?(spree_forgot_password_path) && !paths_equal?(canonical_path, spree_forgot_password_path))
+    end
+
+    def paths_equal?(path1, path2)
+      path1 = URI.parse(path1).path.chomp('/')
+      path2 = URI.parse(path2).path.chomp('/')
+
+      path1 == path2
+    end
+  end
+end

data/app/helpers/spree/storefront_locale_helper.rb

@@ -0,0 +1,42 @@
+module Spree
+  module StorefrontLocaleHelper
+    def current_locale
+      @current_locale ||= if user_locale?
+                            try_spree_current_user.selected_locale
+                          elsif params_locale?
+                            params[:locale]
+                          elsif header_locale?
+                            header_locale
+                          end
+    ensure
+      @current_locale ||= default_locale
+    end
+
+    def header_locale?
+      header_locale.present?
+    end
+
+    # Taken from rack-contrib
+    # https://github.com/rack/rack-contrib/blob/main/lib/rack/contrib/locale.rb#L58
+    def header_locale
+      header = request.env['HTTP_ACCEPT_LANGUAGE']
+
+      return if header.nil?
+
+      locales = header.gsub(/\s+/, '').split(",").map do |language_tag|
+        locale, quality = language_tag.split(/;q=/i)
+        quality = quality ? quality.to_f : 1.0
+        [locale, quality]
+      end
+      locales = locales.
+                reject { |(locale, quality)| locale == '*' || quality.zero? }.
+                sort_by { |(_, quality)| quality }.
+                map(&:first)
+
+      locale_from_header = locales.reverse.find { |locale| supported_locale?(locale) }
+      locale_from_header ||= locales.reverse.find { |locale| supported_locale?(locale.first(2)) }&.first(2)
+
+      locale_from_header
+    end
+  end
+end