spree_core 3.3.6 → 3.4.0.rc1

data/app/models/spree/payment_method/store_credit.rb

@@ -16,7 +16,7 @@ module Spree
       if store_credit.nil?
         ActiveMerchant::Billing::Response.new(false, Spree.t('store_credit_payment_method.unable_to_find'), {}, {})
       else
-        action = -> (store_credit) do
+        action = lambda do |store_credit|
           store_credit.authorize(
             amount_in_cents / 100.0.to_d,
             gateway_options[:currency],
@@ -28,7 +28,7 @@ module Spree
     end
 
     def capture(amount_in_cents, auth_code, gateway_options = {})
-      action = -> (store_credit) do
+      action = lambda do |store_credit|
         store_credit.capture(
           amount_in_cents / 100.0.to_d,
           auth_code,
@@ -57,14 +57,14 @@ module Spree
     end
 
     def void(auth_code, gateway_options = {})
-      action = -> (store_credit) do
+      action = lambda do |store_credit|
         store_credit.void(auth_code, action_originator: gateway_options[:originator])
       end
       handle_action(action, :void, auth_code)
     end
 
     def credit(amount_in_cents, auth_code, gateway_options)
-      action = -> (store_credit) do
+      action = lambda do |store_credit|
         currency = gateway_options[:currency] || store_credit.currency
         originator = gateway_options[:originator]
 
@@ -82,7 +82,7 @@ module Spree
       if !store_credit_event || !store_credit
         handle_action(nil, :cancel, false)
       else
-        action = -> (store_credit) do
+        action = lambda do |store_credit|
           store_credit.credit(store_credit_event.amount, auth_code, store_credit.currency)
         end
         handle_action(action, :cancel, auth_code)

data/app/models/spree/payment_method.rb

@@ -13,8 +13,8 @@ module Spree
     validates :name, presence: true
 
     with_options dependent: :restrict_with_error do
-      has_many :payments, class_name: "Spree::Payment", inverse_of: :payment_method
-      has_many :credit_cards, class_name: "Spree::CreditCard"
+      has_many :payments, class_name: 'Spree::Payment', inverse_of: :payment_method
+      has_many :credit_cards, class_name: 'Spree::CreditCard'
     end
 
     def self.providers
@@ -36,7 +36,7 @@ module Spree
       type.demodulize.downcase
     end
 
-    def self.find_with_destroyed *args
+    def self.find_with_destroyed(*args)
       unscoped { find(*args) }
     end
 
@@ -50,19 +50,19 @@ module Spree
 
     # Custom gateways should redefine this method. See Gateway implementation
     # as an example
-    def reusable_sources(order)
+    def reusable_sources(_order)
       []
     end
 
     def auto_capture?
-      self.auto_capture.nil? ? Spree::Config[:auto_capture] : self.auto_capture
+      auto_capture.nil? ? Spree::Config[:auto_capture] : auto_capture
     end
 
-    def supports?(source)
+    def supports?(_source)
       true
     end
 
-    def cancel(response)
+    def cancel(_response)
       raise ::NotImplementedError, 'You must implement cancel method for this payment method.'
     end
 

data/app/models/spree/preferences/configuration.rb

@@ -33,15 +33,15 @@ module Spree::Preferences
     end
 
     def reset
-      preferences.each do |name, value|
+      preferences.each do |name, _value|
         set_preference name, preference_default(name)
       end
     end
 
-    alias :[] :get_preference
-    alias :[]= :set_preference
+    alias [] get_preference
+    alias []= set_preference
 
-    alias :get :get_preference
+    alias get get_preference
 
     def set(*args)
       options = args.extract_options!
@@ -49,13 +49,11 @@ module Spree::Preferences
         set_preference name, value
       end
 
-      if args.size == 2
-        set_preference args[0], args[1]
-      end
+      set_preference args[0], args[1] if args.size == 2
     end
 
     def method_missing(method, *args)
-      name = method.to_s.gsub('=', '')
+      name = method.to_s.delete('=')
       if has_preference? name
         if method.to_s =~ /=$/
           set_preference(name, args.first)
@@ -66,6 +64,5 @@ module Spree::Preferences
         super
       end
     end
-
   end
 end

data/app/models/spree/preferences/preferable.rb

@@ -59,7 +59,7 @@ module Spree::Preferences::Preferable
   end
 
   def has_preference!(name)
-    raise NoMethodError.new "#{name} preference not defined" unless has_preference? name
+    raise NoMethodError, "#{name} preference not defined" unless has_preference? name
   end
 
   def has_preference?(name)
@@ -81,7 +81,7 @@ module Spree::Preferences::Preferable
   end
 
   def clear_preferences
-    preferences.keys.each {|pref| preferences.delete pref}
+    preferences.keys.each { |pref| preferences.delete pref }
   end
 
   private
@@ -98,24 +98,24 @@ module Spree::Preferences::Preferable
       value.to_i
     when :boolean
       if value.is_a?(FalseClass) ||
-         value.nil? ||
-         value == 0 ||
-         value =~ /^(f|false|0)$/i ||
-         (value.respond_to? :empty? and value.empty?)
-         false
+          value.nil? ||
+          value == 0 ||
+          value =~ /^(f|false|0)$/i ||
+          (value.respond_to?(:empty?) && value.empty?)
+        false
       else
-         true
+        true
       end
     when :array
       value.is_a?(Array) ? value : Array.wrap(value)
     when :hash
       case value.class.to_s
-      when "Hash"
+      when 'Hash'
         value
-      when "String"
+      when 'String'
         # only works with hashes whose keys are strings
         JSON.parse value.gsub('=>', ':')
-      when "Array"
+      when 'Array'
         begin
           value.try(:to_h)
         rescue TypeError

data/app/models/spree/preferences/preferable_class_methods.rb

@@ -1,11 +1,10 @@
 module Spree::Preferences
   module PreferableClassMethods
-
     def preference(name, type, *args)
       options = args.extract_options!
       options.assert_valid_keys(:default)
       default = options[:default]
-      default = ->{ options[:default] } unless default.is_a?(Proc)
+      default = -> { options[:default] } unless default.is_a?(Proc)
 
       # cache_key will be nil for new objects, then if we check if there
       # is a pending preference before going to default
@@ -37,7 +36,7 @@ module Spree::Preferences
     end
 
     def preference_setter_method(name)
-       "preferred_#{name}=".to_sym
+      "preferred_#{name}=".to_sym
     end
 
     def preference_default_getter_method(name)

data/app/models/spree/preferences/scoped_store.rb

@@ -1,6 +1,6 @@
 module Spree::Preferences
   class ScopedStore
-    def initialize prefix, suffix=nil
+    def initialize(prefix, suffix = nil)
       @prefix = prefix
       @suffix = suffix
     end
@@ -9,20 +9,21 @@ module Spree::Preferences
       Spree::Preferences::Store.instance
     end
 
-    def fetch key, &block
+    def fetch(key, &block)
       store.fetch(key_for(key), &block)
     end
 
-    def []= key, value
+    def []=(key, value)
       store[key_for(key)] = value
     end
 
-    def delete key
+    def delete(key)
       store.delete(key_for(key))
     end
 
     private
-    def key_for key
+
+    def key_for(key)
       [rails_cache_id, @prefix, key, @suffix].compact.join('/')
     end
 

data/app/models/spree/preferences/store.rb

@@ -7,7 +7,6 @@
 require 'singleton'
 
 module Spree::Preferences
-
   class StoreInstance
     attr_accessor :persistence
 
@@ -20,11 +19,11 @@ module Spree::Preferences
       @cache.write(key, value)
       persist(key, value)
     end
-    alias_method :[]=, :set
+    alias []= set
 
     def exist?(key)
       @cache.exist?(key) ||
-      should_persist? && Spree::Preference.where(key: key).exists?
+        should_persist? && Spree::Preference.where(key: key).exists?
     end
 
     def get(key)
@@ -40,13 +39,13 @@ module Spree::Preferences
         # has been cleared from the cache
 
         # does it exist in the database?
-        if preference = Spree::Preference.find_by(key: key)
+        val = if preference = Spree::Preference.find_by(key: key)
           # it does exist
-          val = preference.value
-        else
+                preference.value
+              else
           # use the fallback value
-          val = yield
-        end
+                yield
+              end
 
         # Cache either the value from the db or the fallback value.
         # This avoids hitting the db with subsequent queries.
@@ -57,7 +56,7 @@ module Spree::Preferences
         yield
       end
     end
-    alias_method :fetch, :get
+    alias fetch get
 
     def delete(key)
       @cache.delete(key)
@@ -86,15 +85,11 @@ module Spree::Preferences
     end
 
     def should_persist?
-      @persistence and Spree::Preference.table_exists?
-    rescue PG::ConnectionBad, ActiveRecord::NoDatabaseError
-      false
+      @persistence && ActiveRecord::Base.connected? && Spree::Preference.table_exists?
     end
-
   end
 
   class Store < StoreInstance
     include Singleton
   end
-
 end

data/app/models/spree/price.rb

@@ -21,7 +21,7 @@ module Spree
     self.whitelisted_ransackable_attributes = ['amount']
 
     def money
-      Spree::Money.new(amount || 0, { currency: currency })
+      Spree::Money.new(amount || 0, currency: currency)
     end
 
     def amount=(amount)

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

@@ -5,7 +5,7 @@ module Spree
     end
 
     def self.add_search_scope(name, &block)
-      self.singleton_class.send(:define_method, name.to_sym, &block)
+      singleton_class.send(:define_method, name.to_sym, &block)
       search_scopes << name.to_sym
     end
 
@@ -21,18 +21,18 @@ module Spree
     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")
+        next if name.to_s.include?('master_price')
         parts = name.to_s.match(/(.*)_by_(.*)/)
-        self.scope(name.to_s, -> { order("#{Product.quoted_table_name}.#{parts[2]} #{parts[1] == 'ascend' ?  "ASC" : "DESC"}") })
+        scope(name.to_s, -> { order("#{Product.quoted_table_name}.#{parts[2]} #{parts[1] == 'ascend' ? 'ASC' : 'DESC'}") })
       end
     end
 
     def self.property_conditions(property)
       properties = Property.table_name
       conditions = case property
-      when String   then { "#{properties}.name" => property }
-      when Property then { "#{properties}.id" => property.id }
-      else               { "#{properties}.id" => property.to_i }
+                   when String   then { "#{properties}.name" => property }
+                   when Property then { "#{properties}.id" => property.id }
+                   else { "#{properties}.id" => property.to_i }
       end
     end
 
@@ -77,8 +77,8 @@ module Spree
     #   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")
+        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
@@ -98,17 +98,17 @@ module Spree
     # 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))
+      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 }
+                   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)
@@ -117,9 +117,9 @@ module Spree
     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
+                       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
@@ -131,8 +131,8 @@ module Spree
     # 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)
+        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.
@@ -166,7 +166,7 @@ module Spree
     # order: 'COALESCE(cnt, 0) DESC'
     add_search_scope :descend_by_popularity do
       joins(:master).
-      order(%Q{
+        order(%Q{
            COALESCE((
              SELECT
                COUNT(#{LineItem.quoted_table_name}.id)
@@ -195,7 +195,7 @@ module Spree
     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)
+    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
@@ -207,11 +207,11 @@ module Spree
     search_scopes << :active
 
     add_search_scope :taxons_name_eq do |name|
-      group("spree_products.id").joins(:taxons).where(Taxon.arel_table[:name].eq(name))
+      group('spree_products.id').joins(:taxons).where(Taxon.arel_table[:name].eq(name))
     end
 
     def self.distinct_by_product_ids(sort_order = nil)
-      sort_column = sort_order.split(" ").first
+      sort_column = sort_order.split(' ').first
 
       # Postgres will complain when using ordering by expressions not present in
       # SELECT DISTINCT. e.g.
@@ -237,35 +237,35 @@ module Spree
 
     private
 
-      def self.price_table_name
-        Price.quoted_table_name
-      end
+    def self.price_table_name
+      Price.quoted_table_name
+    end
 
-      # 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
+    # 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
 
-      # 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
+    # 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
 
-      def self.get_taxons(*ids_or_records_or_names)
-        taxons = Taxon.table_name
-        ids_or_records_or_names.flatten.map { |t|
-          case t
-          when Integer then Taxon.find_by(id: t)
-          when ApplicationRecord then t
-          when String
-            Taxon.find_by(name: t) ||
+    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
-        }.compact.flatten.uniq
-      end
+        end
+      end.compact.flatten.uniq
+    end
     end
 end

data/app/models/spree/product.rb

@@ -51,20 +51,20 @@ module Spree
     belongs_to :shipping_category, class_name: 'Spree::ShippingCategory', inverse_of: :products
 
     has_one :master,
-      -> { where is_master: true },
-      inverse_of: :product,
-      class_name: 'Spree::Variant'
+            -> { where is_master: true },
+            inverse_of: :product,
+            class_name: 'Spree::Variant'
 
     has_many :variants,
-      -> { where(is_master: false).order(:position) },
-      inverse_of: :product,
-      class_name: 'Spree::Variant'
+             -> { where(is_master: false).order(:position) },
+             inverse_of: :product,
+             class_name: 'Spree::Variant'
 
     has_many :variants_including_master,
-      -> { order(:position) },
-      inverse_of: :product,
-      class_name: 'Spree::Variant',
-      dependent: :destroy
+             -> { order(:position) },
+             inverse_of: :product,
+             class_name: 'Spree::Variant',
+             dependent: :destroy
 
     has_many :prices, -> { order('spree_variants.position, spree_variants.id, currency') }, through: :variants
 
@@ -105,9 +105,9 @@ module Spree
 
     attr_accessor :option_values_hash
 
-    accepts_nested_attributes_for :product_properties, allow_destroy: true, reject_if: lambda { |pp| pp[:property_name].blank? }
+    accepts_nested_attributes_for :product_properties, allow_destroy: true, reject_if: ->(pp) { pp[:property_name].blank? }
 
-    alias :options :product_option_types
+    alias options product_option_types
 
     self.whitelisted_ransackable_associations = %w[stores variants_including_master master variants]
     self.whitelisted_ransackable_attributes = %w[description name slug discontinue_on]
@@ -123,7 +123,7 @@ module Spree
     delegate :display_amount, :display_price, :has_default_price?,
              :images, to: :find_or_build_master
 
-    alias_method :master_images, :images
+    alias master_images images
 
     def find_or_build_master
       master || build_master
@@ -192,7 +192,7 @@ module Spree
     # eg categorise_variants_from_option(color) => {"red" -> [...], "blue" -> [...]}
     def categorise_variants_from_option(opt_type)
       return {} unless option_types.include?(opt_type)
-      variants.active.group_by { |v| v.option_values.detect { |o| o.option_type == opt_type} }
+      variants.active.group_by { |v| v.option_values.detect { |o| o.option_type == opt_type } }
     end
 
     def self.like_any(fields, values)
@@ -307,7 +307,7 @@ module Spree
     end
 
     def update_slug_history
-      self.save!
+      save!
     end
 
     def anything_changed?
@@ -349,7 +349,7 @@ module Spree
       # Required to avoid Variant#check_price validation failing on create.
       unless master.default_price && master.valid?
         master.errors.each do |att, error|
-          self.errors.add(att, error)
+          errors.add(att, error)
         end
       end
     end

data/app/models/spree/promotion/actions/create_item_adjustments.rb

@@ -8,7 +8,8 @@ module Spree
         before_validation -> { self.calculator ||= Calculator::PercentOnLineItem.new }
 
         def perform(options = {})
-          order, promotion = options[:order], options[:promotion]
+          order = options[:order]
+          promotion = options[:promotion]
           create_unique_adjustments(order, order.line_items) do |line_item|
             promotion.line_item_actionable?(order, line_item)
           end

data/app/models/spree/promotion/actions/free_shipping.rb

@@ -4,7 +4,7 @@ module Spree
       class FreeShipping < Spree::PromotionAction
         include Spree::AdjustmentSource
 
-        def perform(payload={})
+        def perform(payload = {})
           order = payload[:order]
           create_unique_adjustments(order, order.shipments)
         end

data/app/models/spree/promotion/rules/first_order.rb

@@ -24,13 +24,14 @@ module Spree
         end
 
         private
-          def completed_orders
-            user ? user.orders.complete : orders_by_email
-          end
 
-          def orders_by_email
-            Spree::Order.where(email: email).complete
-          end
+        def completed_orders
+          user ? user.orders.complete : orders_by_email
+        end
+
+        def orders_by_email
+          Spree::Order.where(email: email).complete
+        end
       end
     end
   end

data/app/models/spree/promotion/rules/item_total.rb

@@ -9,15 +9,14 @@ module Spree
         preference :amount_max, :decimal, default: 1000.00
         preference :operator_max, :string, default: '<'
 
-
         OPERATORS_MIN = ['gt', 'gte']
-        OPERATORS_MAX = ['lt','lte']
+        OPERATORS_MAX = ['lt', 'lte']
 
         def applicable?(promotable)
           promotable.is_a?(Spree::Order)
         end
 
-        def eligible?(order, options = {})
+        def eligible?(order, _options = {})
           item_total = order.item_total
 
           lower_limit_condition = item_total.send(preferred_operator_min == 'gte' ? :>= : :>, BigDecimal.new(preferred_amount_min.to_s))
@@ -30,6 +29,7 @@ module Spree
         end
 
         private
+
         def formatted_amount_min
           Spree::Money.new(preferred_amount_min).to_s
         end
@@ -38,7 +38,6 @@ module Spree
           Spree::Money.new(preferred_amount_max).to_s
         end
 
-
         def ineligible_message_max
           if preferred_operator_max == 'gte'
             eligibility_error_message(:item_total_more_than_or_equal, amount: formatted_amount_max)
@@ -54,7 +53,6 @@ module Spree
             eligibility_error_message(:item_total_less_than_or_equal, amount: formatted_amount_min)
           end
         end
-
       end
     end
   end