spree_frontend 3.1.0 → 4.7.0

data/app/helpers/spree/navigation_helper.rb

@@ -0,0 +1,111 @@
+require 'digest'
+
+module Spree
+  module NavigationHelper
+    def spree_navigation_data
+      Spree::Deprecation.warn(<<-DEPRECATION, caller)
+        NavigationHelper#spree_navigation_data is deprecated and will be removed in Spree 5.0.
+        Please migrate to the new navigation cms system.
+      DEPRECATION
+
+      @spree_navigation_data ||= SpreeStorefrontConfig.dig(I18n.locale,
+                                                           :navigation) || SpreeStorefrontConfig.dig(current_store.code,
+                                                                                                     :navigation) || SpreeStorefrontConfig.dig(
+                                                                                                       :default, :navigation
+                                                                                                     ) || []
+    # safeguard for older Spree installs that don't have spree_navigation initializer
+    # or spree.yml file present
+    rescue StandardError
+      []
+    end
+
+    def spree_nav_cache_key(section = 'header')
+      Spree::Deprecation.warn(<<-DEPRECATION, caller)
+        NavigationHelper#spree_nav_cache_key is deprecated and will be removed in Spree 5.0.
+        Please migrate to the new navigation cms system.
+      DEPRECATION
+
+      @spree_nav_cache_key = begin
+        keys = base_cache_key + [current_store, spree_navigation_data_cache_key, stores&.cache_key_with_version, section]
+        Digest::MD5.hexdigest(keys.join('-'))
+      end
+    end
+
+    def spree_menu_cache_key(section = 'header')
+      keys = base_cache_key + [
+        current_store.cache_key_with_version,
+        spree_menu(section)&.cache_key_with_version,
+        stores&.maximum(:updated_at),
+        section
+      ]
+      Digest::MD5.hexdigest(keys.join('-'))
+    end
+
+    def main_nav_image(image_path, title = '')
+      image_url = asset_path(asset_exists?(image_path) ? image_path : 'noimage/plp.svg')
+
+      lazy_image(
+        src: image_url,
+        alt: title,
+        width: 350,
+        height: 234
+      )
+    end
+
+    def spree_menu(location = 'header')
+      method_name = "for_#{location}"
+
+      if available_menus.respond_to?(method_name) && Spree::Menu::MENU_LOCATIONS_PARAMETERIZED.include?(location)
+        available_menus.send(method_name, I18n.locale) || current_store.default_menu(location)
+      end
+    end
+
+    def spree_localized_link(item)
+      return if item.link.nil?
+
+      output_locale = if locale_param
+                        "/#{I18n.locale}"
+                      end
+
+      if ['Spree::Product', 'Spree::Taxon', 'Spree::CmsPage'].include?(item.linked_resource_type)
+        output_locale.to_s + item.link
+      elsif item.linked_resource_type == 'Home Page'
+        "/#{locale_param}"
+      else
+        item.link
+      end
+    end
+
+    def should_render_internationalization_dropdown?
+      (defined?(should_render_locale_dropdown?) && should_render_locale_dropdown?) ||
+        (defined?(should_render_currency_dropdown?) && should_render_currency_dropdown?)
+    end
+
+    def spree_nav_link_tag(item, opts = {}, &block)
+      if item.new_window
+        target = opts[:target] || '_blank'
+        rel = opts[:rel] || 'noopener noreferrer'
+      end
+
+      active_class = if request && current_page?(spree_localized_link(item))
+                       "active #{opts[:class]}"
+                     else
+                       opts[:class]
+                     end
+
+      link_opts = { target: target, rel: rel, class: active_class, id: opts[:id], data: opts[:data], aria: opts[:aria] }
+
+      if block_given?
+        link_to spree_localized_link(item), link_opts, &block
+      else
+        link_to item.name, spree_localized_link(item), link_opts
+      end
+    end
+
+    private
+
+    def spree_navigation_data_cache_key
+      @spree_navigation_data_cache_key ||= Digest::MD5.hexdigest(spree_navigation_data.to_s)
+    end
+  end
+end

data/app/helpers/spree/orders_helper.rb

@@ -1,14 +1,5 @@
-require 'truncate_html'
-require 'app/helpers/truncate_html_helper'
-
 module Spree
   module OrdersHelper
-    include TruncateHtmlHelper
-
-    def truncated_product_description(product)
-      truncate_html(raw(product.description))
-    end
-
     def order_just_completed?(order)
       flash[:order_completed] && order.present?
     end

data/app/helpers/spree/products_filters_helper.rb

@@ -0,0 +1,168 @@
+module Spree
+  module ProductsFiltersHelper
+    PRICE_FILTER_NAME = 'price'.freeze
+
+    FILTER_LINK_CSS_CLASSES = 'd-inline-block text-uppercase py-1 px-2 m-1 plp-overlay-card-item'.freeze
+    ACTIVE_FILTER_LINK_CSS_CLASSES = 'plp-overlay-card-item--selected'.freeze
+
+    CLEAR_ALL_FILTERS_LINK_CSS_CLASSES = 'btn spree-btn btn-outline-primary w-100 mb-4'.freeze
+
+    def price_filters
+      @price_filters ||= [
+        filters_less_than_price_range(50),
+        filters_price_range(50, 100),
+        filters_price_range(101, 150),
+        filters_price_range(151, 200),
+        filters_price_range(201, 300),
+        filters_more_than_price_range(300)
+      ]
+    end
+
+    def min_price_filter_input(**html_options)
+      price_filter_input(
+        name: :min_price,
+        value: filters_price_range_from_param.min_price.to_i,
+        placeholder: "#{currency_symbol(current_currency)} #{Spree.t(:min)}",
+        **html_options
+      )
+    end
+
+    def max_price_filter_input(**html_options)
+      price_filter_input(
+        name: :max_price,
+        value: filters_price_range_from_param.max_price.to_i,
+        placeholder: "#{currency_symbol(current_currency)} #{Spree.t(:max)}",
+        **html_options
+      )
+    end
+
+    def price_filter_input(name:, value:, placeholder:, **html_options)
+      price_value = value&.zero? ? '' : value
+      style_class = "spree-flat-input #{html_options[:class]}"
+
+      number_field_tag(
+        name, price_value,
+        id: name,
+        class: style_class,
+        min: 0, step: 1, placeholder: placeholder,
+        **html_options.except(:class)
+      )
+    end
+
+    def option_value_filter_link(option_value, permitted_params, opts = {})
+      id = option_value.id
+      ot_downcase_name = option_value.option_type.filter_param
+      selected_option_values = params[ot_downcase_name]&.split(',')&.map(&:to_i) || []
+      is_selected = selected_option_values.include?(id)
+      option_value_param = (is_selected ? selected_option_values - [id] : selected_option_values + [id]).join(',')
+      new_params = permitted_params.merge(ot_downcase_name => option_value_param, menu_open: 1)
+
+      link_to new_params, data: { params: new_params, id: id, filter_name: ot_downcase_name, multiselect: true } do
+        # TODO: refactor this
+        if color_option_type_name.present? && color_option_type_name.downcase == ot_downcase_name
+          content_tag :span, class: 'd-inline-block mb-1' do
+            render partial: 'spree/shared/color_select', locals: {
+              color: option_value.presentation,
+              selected: is_selected
+            }
+          end
+        else
+          filter_content_tag(option_value.presentation, opts.merge(is_selected: is_selected))
+        end
+      end
+    end
+
+    def property_value_filter_link(property, value, permitted_params, opts = {})
+      id = value.first
+      name = value.last
+
+      selected_properties = params.dig(:properties, property.filter_param)&.split(',') || []
+      is_selected = selected_properties.include?(id)
+      property_values = (is_selected ? selected_properties - [id] : selected_properties + [id])
+      url = permitted_params.merge(properties: { property.filter_param => property_values }, menu_open: 1)
+      filter_name = "properties[#{property.filter_param}]"
+      new_params = permitted_params.merge(filter_name => property_values, menu_open: 1)
+
+      base_filter_link(url, name, opts.merge(params: new_params, is_selected: is_selected, filter_name: filter_name, id: id, multiselect: true))
+    end
+
+    def price_filter_link(price_range, permitted_params, opts = {})
+      is_selected = params[:price] == price_range.to_param
+      price_param = is_selected ? '' : price_range.to_param
+      url = permitted_params.merge(price: price_param, menu_open: 1)
+
+      opts[:is_selected] ||= is_selected
+
+      content_tag :div do
+        base_filter_link(url, price_range, opts.merge(is_selected: is_selected, filter_name: PRICE_FILTER_NAME, id: price_param))
+      end
+    end
+
+    def product_filters_present?(permitted_params)
+      properties = permitted_params.fetch(:properties, {}).to_unsafe_h
+      flatten_params = permitted_params.to_h.merge(properties)
+
+      flatten_params.any? { |name, value| product_filter_present?(name, value) }
+    end
+
+    def clear_all_filters_link(permitted_params, opts = {})
+      opts[:css_class] ||= CLEAR_ALL_FILTERS_LINK_CSS_CLASSES
+      sort_by_param = permitted_params.slice(:sort_by)
+
+      link_to Spree.t('plp.clear_all'), sort_by_param, class: opts[:css_class], data: { params: sort_by_param }
+    end
+
+    private
+
+    def product_filter_present?(filter_param, filter_value)
+      filter_param.in?(product_filters_params) && filter_value.present?
+    end
+
+    def product_filters_params
+      options_filter_params = OptionType.filterable.map(&:filter_param)
+      properties_filter_params = Property.filterable.pluck(:filter_param)
+
+      options_filter_params + properties_filter_params + [PRICE_FILTER_NAME]
+    end
+
+    def base_filter_link(url, label, opts = {})
+      opts[:params] ||= url
+
+      link_to url, data: { filter_name: opts[:filter_name], id: opts[:id], params: opts[:params], multiselect: opts[:multiselect] } do
+        filter_content_tag(label, opts)
+      end
+    end
+
+    def filter_content_tag(label, opts = {})
+      opts[:css_class]        ||= FILTER_LINK_CSS_CLASSES
+      opts[:css_active_class] ||= ACTIVE_FILTER_LINK_CSS_CLASSES
+
+      content_tag :div, class: "#{opts[:css_class]} #{opts[:css_active_class] if opts[:is_selected]}" do
+        label.to_s
+      end
+    end
+
+    def filters_price_range_from_param
+      Filters::PriceRangePresenter.from_param(params[:price].to_s, currency: current_currency)
+    end
+
+    def filters_price_range(min_amount, max_amount)
+      Filters::PriceRangePresenter.new(
+        min_price: filters_price(min_amount),
+        max_price: filters_price(max_amount)
+      )
+    end
+
+    def filters_less_than_price_range(amount)
+      Filters::QuantifiedPriceRangePresenter.new(price: filters_price(amount), quantifier: :less_than)
+    end
+
+    def filters_more_than_price_range(amount)
+      Filters::QuantifiedPriceRangePresenter.new(price: filters_price(amount), quantifier: :more_than)
+    end
+
+    def filters_price(amount)
+      Filters::PricePresenter.new(amount: amount, currency: current_currency)
+    end
+  end
+end

data/app/helpers/spree/store_helper.rb

@@ -1,10 +1,41 @@
-# Methods added to this helper will be available to all templates in the frontend.
 module Spree
   module StoreHelper
-    def cache_key_for_taxons
-      max_updated_at = @taxons.maximum(:updated_at).to_i
-      parts = [@taxon.try(:id), max_updated_at].compact.join("-")
-      "#{I18n.locale}/taxons/#{parts}"
+    include LocaleHelper
+
+    def store_country_iso(store = nil)
+      store ||= current_store if defined?(current_store)
+
+      store&.default_country&.iso&.downcase
+    end
+
+    def stores
+      @stores ||= Spree::Store.includes(:default_country).order(:id)
+    end
+
+    def store_currency_symbol(store = nil)
+      store ||= current_store  if defined?(current_store)
+      return unless store&.default_currency
+
+      ::Money::Currency.find(store.default_currency).symbol
+    end
+
+    def store_locale_name(store = nil)
+      store ||= current_store if defined?(current_store)
+      return unless store
+      return store.name if store.default_locale.blank?
+
+      locale_full_name(store.default_locale)
+    end
+
+    def should_render_store_chooser?
+      Spree::Frontend::Config[:show_store_selector] && stores.size > 1
+    end
+
+    def store_link(store = nil, html_opts = {})
+      store ||= current_store if defined?(current_store)
+      return unless store
+
+      link_to "#{store_locale_name(store)} (#{store_currency_symbol(store)})", store.formatted_url, **html_opts
     end
   end
 end

data/app/helpers/spree/structured_data_helper.rb

@@ -0,0 +1,50 @@
+module Spree
+  module StructuredDataHelper
+    def products_structured_data(products)
+      content_tag :script, type: 'application/ld+json' do
+        raw(
+          products.map do |product|
+            structured_product_hash(product)
+          end.to_json
+        )
+      end
+    end
+
+    private
+
+    def structured_product_hash(product)
+      Rails.cache.fetch(common_product_cache_keys + ["spree/structured-data/#{product.cache_key_with_version}"]) do
+        {
+          '@context': 'https://schema.org/',
+          '@type': 'Product',
+          '@id': "#{spree.root_url}product_#{product.id}",
+          url: spree.product_url(product),
+          name: product.name,
+          image: structured_images(product),
+          description: product.description,
+          sku: structured_sku(product),
+          offers: {
+            '@type': 'Offer',
+            price: product.default_variant.price_in(current_currency).amount,
+            priceCurrency: current_currency,
+            availability: product.in_stock? ? 'InStock' : 'OutOfStock',
+            url: spree.product_url(product),
+            availabilityEnds: product.discontinue_on ? product.discontinue_on.strftime('%F') : ''
+          }
+        }
+      end
+    end
+
+    def structured_sku(product)
+      product.default_variant.sku? ? product.default_variant.sku : product.sku
+    end
+
+    def structured_images(product)
+      image = default_image_for_product_or_variant(product)
+
+      return '' unless image
+
+      main_app.rails_blob_url(image.attachment)
+    end
+  end
+end

data/app/helpers/spree/taxons_helper.rb

@@ -3,14 +3,17 @@ module Spree
     # Retrieves the collection of products to display when "previewing" a taxon.  This is abstracted into a helper so
     # that we can use configurations as well as make it easier for end users to override this determination.  One idea is
     # to show the most popular products for a particular taxon (that is an exercise left to the developer.)
-    def taxon_preview(taxon, max=4)
-      products = taxon.active_products.select("spree_products.*, spree_products_taxons.position").limit(max)
-      if (products.size < max)
+    def taxon_preview(taxon, max = 4)
+      Spree::Deprecation.warn(<<-DEPRECATION, caller)
+        TaxonsHelper is deprecated and will be removed in Spree 5.0.
+        Please remove any `helper 'spree/taxons'` from your controllers.
+      DEPRECATION
+      products = taxon.active_products.distinct.select('spree_products.*, spree_products_taxons.position').limit(max)
+      if products.size < max
         products_arel = Spree::Product.arel_table
-        taxon.descendants.each do |taxon|
+        taxon.descendants.each do |child|
           to_get = max - products.length
-          products += taxon.active_products.select("spree_products.*, spree_products_taxons.position").
-                      where(products_arel[:id].not_in(products.map(&:id))).limit(to_get)
+          products += child.active_products.distinct.select('spree_products.*, spree_products_taxons.position').where(products_arel[:id].not_in(products.map(&:id))).limit(to_get)
           break if products.size >= max
         end
       end

data/app/services/spree/build_localized_redirect_url.rb

@@ -0,0 +1,141 @@
+require 'uri'
+
+module Spree
+  class BuildLocalizedRedirectUrl
+    prepend Spree::ServiceModule::Base
+
+    LOCALE_REGEX = /^\/([A-Za-z]{2})\/|^\/([A-Za-z]{2}-[A-Za-z]{2})\/|^\/([A-Za-z]{2})$|^\/([A-Za-z]{2}-[A-Za-z]{2})$/.freeze
+
+    SUPPORTED_PATHS_REGEX = /\/(products|t\/|cart|checkout|addresses|content|pages|login|account|logout|signup|users)/.freeze
+
+    PRODUCT_PATH_REGEX = /\/products\/(\S+)/.freeze
+    TAXON_PATH_REGEX = /\/t\/(\S+)/.freeze
+
+    # rubocop:disable Lint/UnusedMethodArgument
+    def call(url:, locale:, default_locale: nil)
+      run :initialize_url_object
+      run :generate_new_path
+      run :append_locale_param
+      run :build_url
+    end
+    # rubocop:enable Lint/UnusedMethodArgument
+
+    protected
+
+    def initialize_url_object(url:, locale:, default_locale:)
+      success(
+        url: URI(url),
+        locale: locale,
+        default_locale: default_locale,
+        default_locale_supplied: default_locale_supplied?(locale, default_locale)
+      )
+    end
+
+    def generate_new_path(url:, locale:, default_locale:, default_locale_supplied:)
+      unless supported_path?(url.path)
+        return success(
+          url: url,
+          locale: locale,
+          path: cleanup_path(url.path),
+          default_locale_supplied: default_locale_supplied,
+          locale_added_to_path: false
+        )
+      end
+
+
+      locale_url_match = url.path.match(LOCALE_REGEX)
+      previous_locale = locale_url_match ? locale_url_match[1] || default_locale : default_locale
+
+      product_path_match = url.path.match(PRODUCT_PATH_REGEX)
+      taxon_path_match = url.path.match(TAXON_PATH_REGEX)
+
+      if product_path_match
+        new_path = generate_product_path(product_path_match, previous_locale, locale, default_locale, default_locale_supplied)
+      elsif url.path.match(TAXON_PATH_REGEX)
+        new_path = generate_taxon_path(taxon_path_match, previous_locale, locale, default_locale, default_locale_supplied)
+      else
+        new_path = generate_regular_page_path(default_locale_supplied, url, locale)
+      end
+
+      success(
+        url: url,
+        locale: locale,
+        path: cleanup_path(new_path),
+        default_locale_supplied: default_locale_supplied,
+        locale_added_to_path: true
+      )
+    end
+
+    def append_locale_param(url:, locale:, path:, default_locale_supplied:, locale_added_to_path:)
+      return success(url: url, path: path, query: url.query) if locale_added_to_path
+
+      query_params = Rack::Utils.parse_nested_query(url.query)
+
+      if default_locale_supplied
+        query_params.delete('locale')
+      else
+        query_params.merge!('locale' => locale)
+      end
+
+      query_string = query_params.any? ? query_params.to_query : nil
+
+      success(url: url, path: path, query: query_string)
+    end
+
+    def build_url(url:, path:, query:)
+      localized_url = builder_class(url).build(host: url.host, port: url.port, path: path, query: query).to_s
+      success(localized_url)
+    end
+
+    private
+
+    def supported_path?(path)
+      return true if path.blank? || path == '/' || maches_locale_regex?(path)
+
+      path.match(SUPPORTED_PATHS_REGEX)
+    end
+
+    def maches_locale_regex?(path)
+      path.match(LOCALE_REGEX)[0].gsub('/', '') if path.match(LOCALE_REGEX)
+    end
+
+    def default_locale_supplied?(locale, default_locale)
+      default_locale.present? && default_locale.to_s == locale.to_s
+    end
+
+    def cleanup_path(path)
+      path.chomp('/').gsub('//', '/')
+    end
+
+    def builder_class(url)
+      url.scheme == 'http' ? URI::HTTP : URI::HTTPS
+    end
+
+    def generate_product_path(product_path_match, previous_locale, locale, default_locale, default_locale_supplied)
+      product = begin
+        Mobility.with_locale(previous_locale) { Spree::Product.friendly.find(product_path_match[1]) }
+      rescue ActiveRecord::RecordNotFound
+        Mobility.with_locale(default_locale) { Spree::Product.friendly.find(product_path_match[1]) }
+      end
+
+      new_slug = product.slug(locale: locale) || product.slug(locale: default_locale)
+      new_path_slug = "/products/#{new_slug}"
+      default_locale_supplied ? new_path_slug : "/#{locale}/#{new_path_slug}"
+    end
+
+    def generate_taxon_path(taxon_path_match, previous_locale, locale, default_locale, default_locale_supplied)
+      taxon = Mobility.with_locale(previous_locale) { Spree::Taxon.friendly.find(taxon_path_match[1]) }
+      new_slug = taxon.permalink(locale: locale) || taxon.permalink(locale: default_locale)
+      new_path_slug = "/t/#{new_slug}"
+      default_locale_supplied ? new_path_slug : "/#{locale}/#{new_path_slug}"
+    end
+
+    def generate_regular_page_path(default_locale_supplied, url, locale)
+      if default_locale_supplied
+        maches_locale_regex?(url.path) ? url.path.gsub(LOCALE_REGEX, '/') : url.path
+      else
+        maches_locale_regex?(url.path) ? url.path.gsub(LOCALE_REGEX, "/#{locale}/") : "/#{locale}#{url.path}"
+      end
+    end
+  end
+end

data/app/views/kaminari/{twitter-bootstrap-3 → twitter-bootstrap-4}/_first_page.html.erb

@@ -4,10 +4,10 @@
     current_page:  a page object for the currently displayed page
     total_pages:   total number of pages
     per_page:      number of items to fetch per page
-    remote:        data-remote
--%>
+    remote:        data-remote -%>
+
 <% unless current_page.first? %>
-  <li class="first">
-    <%= link_to_unless current_page.first?, raw(t 'views.pagination.first'), url, :remote => remote %>
+  <li class="first page-item">
+    <%= link_to_unless current_page.first?, inline_svg_tag('pagination-double-arrow-right.svg', size: '13px*16px', class: 'spree-icon-arrow-left'), url, remote: remote, class: 'page-link', 'aria-label': 'First page' %>
   </li>
 <% end %>

data/app/views/kaminari/{twitter-bootstrap-3 → twitter-bootstrap-4}/_gap.html.erb

@@ -3,6 +3,10 @@
     current_page:  a page object for the currently displayed page
     total_pages:   total number of pages
     per_page:      number of items to fetch per page
-    remote:        data-remote
--%>
-<li class="page gap disabled"><a href="#" onclick="return false;"><%= raw(t 'views.pagination.truncate') %></a></li>
+    remote:        data-remote -%>
+
+<li class="page gap disabled page-item d-none d-lg-flex">
+  <a href="#" onclick="return false;" class="page-link">
+    <%= raw(t 'views.pagination.truncate') %>
+  </a>
+</li>

data/app/views/kaminari/twitter-bootstrap-4/_last_page.html.erb

@@ -0,0 +1,13 @@
+<%# Link to the "Last" page
+  - available local variables
+    url:           url to the last page
+    current_page:  a page object for the currently displayed page
+    total_pages:   total number of pages
+    per_page:      number of items to fetch per page
+    remote:        data-remote -%>
+
+<% unless current_page.last? %>
+  <li class="last next page-item"><%# "next" class present for border styling in twitter bootstrap %>
+    <%= link_to_unless current_page.last?, inline_svg_tag('pagination-double-arrow-right.svg', size: '13px*16px'), url, remote: remote, class: 'page-link', 'aria-label': 'Last page' %>
+  </li>
+<% end %>

data/app/views/kaminari/{twitter-bootstrap-3 → twitter-bootstrap-4}/_next_page.html.erb

@@ -4,10 +4,10 @@
     current_page:  a page object for the currently displayed page
     total_pages:   total number of pages
     per_page:      number of items to fetch per page
-    remote:        data-remote
--%>
+    remote:        data-remote -%>
+
 <% unless current_page.last? %>
-  <li class="next_page">
-    <%= link_to_unless current_page.last?, raw(t 'views.pagination.next'), url, :rel => 'next', :remote => remote %>
+  <li class="next_page page-item">
+    <%= link_to_unless current_page.last?, inline_svg_tag('pagination-arrow-right.svg', size: '13px*16px'), url, rel: 'next', remote: remote, class: 'page-link', 'aria-label': 'Next page' %>
   </li>
 <% end %>

data/app/views/kaminari/{twitter-bootstrap-3 → twitter-bootstrap-4}/_page.html.erb

@@ -5,8 +5,14 @@
     current_page:  a page object for the currently displayed page
     total_pages:   total number of pages
     per_page:      number of items to fetch per page
-    remote:        data-remote
--%>
-<li class="page<%= ' active' if page.current? %>">
-  <%= link_to page, url, opts = {:remote => remote, :rel => page.next? ? 'next' : page.prev? ? 'prev' : nil} %>
+    remote:        data-remote -%>
+
+<li class="page<%= ' active' if page.current? %> page-item">
+  <%= link_to page,
+    url,
+    opts = {
+      remote: remote,
+      rel: page.next? ? 'next' : page.prev? ? 'prev' : nil,
+      class: 'page-link'
+    } %>
 </li>

data/app/views/kaminari/{twitter-bootstrap-3 → twitter-bootstrap-4}/_paginator.html.erb

@@ -4,12 +4,12 @@
     total_pages:   total number of pages
     per_page:      number of items to fetch per page
     remote:        data-remote
-    paginator:     the paginator that renders the pagination tags inside
--%>
+    paginator:     the paginator that renders the pagination tags inside -%>
+
 <% pagination_class ||= '' %>
 
 <%= paginator.render do %>
-  <ul class="pagination <%= pagination_class %>">
+  <ul class="pagination mt-4 <%= pagination_class %>">
     <%= first_page_tag unless current_page.first? %>
     <%= prev_page_tag unless current_page.first? %>
     <% each_page do |page| %>

data/app/views/kaminari/{twitter-bootstrap-3 → twitter-bootstrap-4}/_prev_page.html.erb

@@ -4,10 +4,10 @@
     current_page:  a page object for the currently displayed page
     total_pages:   total number of pages
     per_page:      number of items to fetch per page
-    remote:        data-remote
--%>
+    remote:        data-remote -%>
+
 <% unless current_page.first? %>
-  <li class="prev">
-    <%= link_to_unless current_page.first?, raw(t 'views.pagination.previous'), url, :rel => 'prev', :remote => remote %>
+  <li class="prev page-item">
+    <%= link_to_unless current_page.first?, inline_svg_tag('pagination-arrow-right.svg', size: '13px*16px', class: 'spree-icon-arrow-left'), url, rel: 'prev', remote: remote, class: 'page-link', 'aria-label': 'Previous page' %>
   </li>
 <% end %>