spree_core 3.7.14.1 → 4.0.0.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b9cc428b39c96e67b7e2e583875d442facf63b1bd6c9c26330db42ca684eb99d
-  data.tar.gz: 3b79b1afc23ccf9ae7a68799564d1030c1a8dd8de24f317b94ea70a81fd351b1
+  metadata.gz: 5064fe41cb92fc49b65d326a8104d304e34e53b14cd8ad841207bef116b35464
+  data.tar.gz: c5288fc5c3b503961af981fe4c374e4bafcb93cb117dcd6e9be983d2c06f96e8
 SHA512:
-  metadata.gz: 0f2ed5997f20f2d97d8311cc279b87f7ec86df92dbfa177bdfd32ed5875d5ae3038e663318ca505bac3b0e7b5dd535b74950146d0810051a189de35723482f64
-  data.tar.gz: fd547459e0f2a51a96de5de296ee228e9ca80f70f28e5020b7bf7d460a26520c565a2e6a78aba2296b570d752da3f7c4bdf850ef3d951ecc76c4681f4c5138ea
+  metadata.gz: b70df4383270e04fc466c704e7d97ca152793bb74eec3ca7f66cbe901700671255eb2d94016b66031f43f57fa40ab9817f3498a272624a383a392d998ff675ed
+  data.tar.gz: 2eaf71128b93b12a4502d4bdb0ef0719ab39c480968a8436b422a723d6c7c43e97c323df636259fe03891fbf924c3043fafab4dc1e505fafa13317717a4c6fbf

data/Gemfile

@@ -1,3 +1,3 @@
-eval(File.read(File.dirname(__FILE__) + '/../common_spree_dependencies.rb'))
+eval_gemfile('../common_spree_dependencies.rb')
 
 gemspec

data/app/controllers/spree/base_controller.rb

@@ -3,7 +3,6 @@ require_dependency 'spree/core/controller_helpers/strong_parameters'
 
 class Spree::BaseController < ApplicationController
   include Spree::Core::ControllerHelpers::Auth
-  include Spree::Core::ControllerHelpers::RespondWith
   include Spree::Core::ControllerHelpers::Common
   include Spree::Core::ControllerHelpers::Search
   include Spree::Core::ControllerHelpers::Store

data/app/finders/spree/taxons/find.rb

@@ -3,11 +3,12 @@ module Spree
     class Find
       def initialize(scope:, params:)
         @scope = scope
-        @ids      = String(params.dig(:filter, :ids)).split(',')
-        @parent   = params.dig(:filter, :parent_id)
-        @taxonomy = params.dig(:filter, :taxonomy_id)
-        @name     = params.dig(:filter, :name)
-        @roots    = params.dig(:filter, :roots)
+
+        @ids      = String(params[:ids]).split(',')
+        @parent   = params[:parent_id]
+        @taxonomy = params[:taxonomy_id]
+        @name     = params[:name]
+        @roots    = params[:roots]
       end
 
       def execute

data/app/helpers/spree/base_helper.rb

@@ -79,15 +79,6 @@ module Spree
       spree.nested_taxons_path(taxon.permalink)
     end
 
-    # human readable list of variant options
-    def variant_options(variant, _options = {})
-      ActiveSupport::Deprecation.warn(<<-DEPRECATION, caller)
-        BaseHelper#variant_options is deprecated and will be removed in Spree 4.0.
-        Please use Variant#options_text or LineItem#options_text
-      DEPRECATION
-      variant.options_text
-    end
-
     def frontend_available?
       Spree::Core::Engine.frontend_available?
     end

data/app/helpers/spree/products_helper.rb

@@ -36,7 +36,7 @@ module Spree
                     else
                       product.description.to_s.gsub(/(.*?)\r?\n\r?\n/m, '<p>\1</p>')
                     end
-      description.blank? ? Spree.t(:product_has_no_description) : raw(description)
+      description.blank? ? Spree.t(:product_has_no_description) : description
     end
 
     def line_item_description_text(description_text)

data/app/models/concerns/spree/product_scopes.rb

@@ -0,0 +1,254 @@
+module Spree
+  module ProductScopes
+    extend ActiveSupport::Concern
+
+    included 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.simple_scopes
+        [
+          :ascend_by_updated_at,
+          :descend_by_updated_at,
+          :ascend_by_name,
+          :descend_by_name
+        ]
+      end
+
+      def self.add_simple_scopes(scopes)
+        scopes.each do |name|
+          # We should not define price scopes here, as they require something slightly different
+          next if name.to_s.include?('master_price')
+
+          parts = name.to_s.match(/(.*)_by_(.*)/)
+          scope(name.to_s, -> { order(Arel.sql("#{Product.quoted_table_name}.#{parts[2]} #{parts[1] == 'ascend' ? 'ASC' : 'DESC'}")) })
+        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
+
+      add_simple_scopes simple_scopes
+
+      add_search_scope :ascend_by_master_price do
+        joins(master: :default_price).order("#{price_table_name}.amount ASC")
+      end
+
+      add_search_scope :descend_by_master_price do
+        joins(master: :default_price).order("#{price_table_name}.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 :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
+
+      # 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)).
+          order('spree_products_taxons.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
+
+      # 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("#{ProductProperty.table_name}.value = ?", value).
+          where(property_conditions(property))
+      end
+
+      add_search_scope :with_option do |option|
+        option_types = 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
+
+      add_search_scope :with_option_value do |option, value|
+        option_values = OptionValue.table_name
+        option_type_id = case option
+                         when String then OptionType.find_by(name: option) || option.to_i
+                         when 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
+
+      # 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("#{OptionValue.table_name}.name = ? OR #{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 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 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(%Q{
+             COALESCE((
+               SELECT
+                 COUNT(#{LineItem.quoted_table_name}.id)
+               FROM
+                 #{LineItem.quoted_table_name}
+               JOIN
+                 #{Variant.quoted_table_name} AS popular_variants
+               ON
+                 popular_variants.id = #{LineItem.quoted_table_name}.variant_id
+               WHERE
+                 popular_variants.product_id = #{Product.quoted_table_name}.id
+             ), 0) DESC
+          })
+      end
+
+      add_search_scope :not_deleted do
+        where("#{Product.quoted_table_name}.deleted_at IS NULL or #{Product.quoted_table_name}.deleted_at >= ?", Time.zone.now)
+      end
+
+      def self.not_discontinued(only_not_discontinued = true)
+        if only_not_discontinued != '0' && only_not_discontinued
+          where("#{Product.quoted_table_name}.discontinue_on IS NULL or #{Product.quoted_table_name}.discontinue_on >= ?", Time.zone.now)
+        else
+          all
+        end
+      end
+      search_scopes << :not_discontinued
+      # Can't use add_search_scope for this as it needs a default argument
+      def self.available(available_on = nil, _currency = nil)
+        available_on ||= Time.current
+        not_discontinued.joins(master: :prices).where("#{Product.quoted_table_name}.available_on <= ?", available_on)
+      end
+      search_scopes << :available
+
+      def self.active(currency = nil)
+        available(nil, currency)
+      end
+      search_scopes << :active
+
+      add_search_scope :taxons_name_eq do |name|
+        group('spree_products.id').joins(:taxons).where(Taxon.arel_table[:name].eq(name))
+      end
+
+      def self.price_table_name
+        Price.quoted_table_name
+      end
+      private_class_method :price_table_name
+
+      # specifically avoid having an order for taxon search (conflicts with main order)
+      def self.prepare_taxon_conditions(taxons)
+        ids = taxons.map { |taxon| taxon.self_and_descendants.pluck(:id) }.flatten.uniq
+        joins(:classifications).where(Classification.table_name => { taxon_id: ids })
+      end
+      private_class_method :prepare_taxon_conditions
+
+      # Produce an array of keywords for use in scopes.
+      # Always return array with at least an empty string to avoid SQL errors
+      def self.prepare_words(words)
+        return [''] if words.blank?
+
+        a = words.split(/[,\s]/).map(&:strip)
+        a.any? ? a : ['']
+      end
+      private_class_method :prepare_words
+
+      def self.get_taxons(*ids_or_records_or_names)
+        taxons = Taxon.table_name
+        ids_or_records_or_names.flatten.map do |t|
+          case t
+          when Integer then Taxon.find_by(id: t)
+          when ApplicationRecord then t
+          when String
+            Taxon.find_by(name: t) ||
+              Taxon.where("#{taxons}.permalink LIKE ? OR #{taxons}.permalink = ?", "%/#{t}/", "#{t}/").first
+          end
+        end.compact.flatten.uniq
+      end
+      private_class_method :get_taxons
+    end
+  end
+end

data/app/models/concerns/spree/user_address.rb

@@ -13,18 +13,21 @@ module Spree
 
       accepts_nested_attributes_for :ship_address, :bill_address
 
+      has_many :addresses, -> { where(deleted_at: nil).order('updated_at DESC') },
+                           class_name: 'Spree::Address', foreign_key: :user_id
+
       def persist_order_address(order)
         b_address = bill_address || build_bill_address
         b_address.attributes = order.bill_address.value_attributes
         b_address.save
-        update_attributes(bill_address_id: b_address.id)
+        update(bill_address_id: b_address.id)
 
         # May not be present if delivery step has been removed
         if order.ship_address
           s_address = ship_address || build_ship_address
           s_address.attributes = order.ship_address.value_attributes
           s_address.save
-          update_attributes(ship_address_id: s_address.id)
+          update(ship_address_id: s_address.id)
         end
       end
     end

data/app/models/friendly_id/slug_decorator.rb

@@ -1,3 +1,9 @@
-FriendlyId::Slug.class_eval do
-  acts_as_paranoid
+module FriendlyId
+  module SlugDecorator
+    def self.prepended(base)
+      base.acts_as_paranoid
+    end
+  end
 end
+
+FriendlyId::Slug.prepend FriendlyId::SlugDecorator

data/app/models/spree/ability.rb

@@ -23,15 +23,8 @@ module Spree
     end
 
     def initialize(user)
-      clear_aliased_actions
-
-      # override cancan default aliasing (we don't want to differentiate between read and index)
+      # add cancancan aliasing
       alias_action :delete, to: :destroy
-      alias_action :edit, to: :update
-      alias_action :new, to: :create
-      alias_action :new_action, to: :create
-      alias_action :show, to: :read
-      alias_action :index, :read, to: :display
       alias_action :create, :update, :destroy, to: :modify
 
       user ||= Spree.user_class.new
@@ -39,27 +32,33 @@ module Spree
       if user.respond_to?(:has_spree_role?) && user.has_spree_role?('admin')
         can :manage, :all
       else
-        can :display, Country
-        can :display, OptionType
-        can :display, OptionValue
+        can :read, Country
+        can :read, OptionType
+        can :read, OptionValue
         can :create, Order
-        can :read, Order do |order, token|
+        can :show, Order do |order, token|
           order.user == user || order.token && token == order.token
         end
         can :update, Order do |order, token|
           !order.completed? && (order.user == user || order.token && token == order.token)
         end
-        can :display, CreditCard, user_id: user.id
-        can :display, Product
-        can :display, ProductProperty
-        can :display, Property
+        can :manage, Spree::Address do |address|
+          address.user == user
+        end
+        can :create, Spree::Address do |_address|
+          user.id.present?
+        end
+        can :read, CreditCard, user_id: user.id
+        can :read, Product
+        can :read, ProductProperty
+        can :read, Property
         can :create, Spree.user_class
-        can [:read, :update, :destroy], Spree.user_class, id: user.id
-        can :display, State
-        can :display, Taxon
-        can :display, Taxonomy
-        can :display, Variant
-        can :display, Zone
+        can [:show, :update, :destroy], Spree.user_class, id: user.id
+        can :read, State
+        can :read, Taxon
+        can :read, Taxonomy
+        can :read, Variant
+        can :read, Zone
       end
 
       # Include any abilities registered by extensions, etc.

data/app/models/spree/address.rb

@@ -12,10 +12,12 @@ module Spree
 
     # we're not freezing this on purpose so developers can extend and manage
     # those attributes depending of the logic of their applications
-    EXCLUDED_KEYS_FOR_COMPARISION = %w(id updated_at created_at)
+    ADDRESS_FIELDS = %w(firstname lastname company address1 address2 city state zipcode country phone)
+    EXCLUDED_KEYS_FOR_COMPARISION = %w(id updated_at created_at deleted_at user_id)
 
     belongs_to :country, class_name: 'Spree::Country'
     belongs_to :state, class_name: 'Spree::State', optional: true
+    belongs_to :user, class_name: Spree.user_class.name, optional: true
 
     has_many :shipments, inverse_of: :address
 
@@ -49,12 +51,10 @@ module Spree
       end
     end
 
-    def iso_name
-      ActiveSupport::Deprecation.warn(<<-DEPRECATION, caller)
-    Address#iso_name is deprecated and will be removed in Spree 4.0.
-    Please use Address#country_iso_name instead
-      DEPRECATION
-      country_iso_name
+    def self.required_fields
+      Spree::Address.validators.map do |v|
+        v.is_a?(ActiveModel::Validations::PresenceValidator) ? v.attributes : []
+      end.flatten
     end
 
     def full_name
@@ -69,24 +69,15 @@ module Spree
       state_name.present? ? state_name : state&.name
     end
 
-    def same_as?(other)
-      ActiveSupport::Deprecation.warn(<<-EOS, caller)
-        Address#same_as? is deprecated and will be removed in Spree 4.0. Please use Address#== instead"
-      EOS
-
-      self == other
-    end
-
-    def same_as(other)
-      ActiveSupport::Deprecation.warn(<<-EOS, caller)
-        Address#same_as is deprecated and will be removed in Spree 4.0. Please use Address#== instead"
-      EOS
-
-      self == other
-    end
-
     def to_s
-      "#{full_name}: #{address1}"
+      [
+        full_name,
+        company,
+        address1,
+        address2,
+        "#{city}, #{state_text} #{zipcode}",
+        country.to_s
+      ].reject(&:blank?).map { |attribute| ERB::Util.html_escape(attribute) }.join('<br/>')
     end
 
     def clone
@@ -129,6 +120,28 @@ module Spree
       country ? country.zipcode_required? : true
     end
 
+    def editable?
+      new_record? || (shipments.empty? && !Order.complete.where('bill_address_id = ? OR ship_address_id = ?', id, id).exists?)
+    end
+
+    def can_be_deleted?
+      shipments.empty? && !Order.where('bill_address_id = ? OR ship_address_id = ?', id, id).exists?
+    end
+
+    def check
+      attrs = attributes.except('id', 'updated_at', 'created_at')
+      the_same_address = user&.addresses&.find_by(attrs)
+      the_same_address || self
+    end
+
+    def destroy
+      if can_be_deleted?
+        super
+      else
+        update_column :deleted_at, Time.current
+      end
+    end
+
     private
 
     def clear_state