solidus_core 1.2.3 → 1.3.0.beta1

data/app/models/spree/product.rb

@@ -48,7 +48,7 @@ module Spree
       class_name: 'Spree::Variant',
       dependent: :destroy
 
-    has_many :prices, -> { order(Spree::Variant.arel_table[:position].asc, Spree::Variant.arel_table[:id].asc, :currency) }, through: :variants
+    has_many :prices, -> { order(Spree::Variant.arel_table[:position].asc, Spree::Variant.arel_table[:id].asc, :currency) }, through: :variants_including_master
 
     has_many :stock_items, through: :variants_including_master
 
@@ -59,7 +59,7 @@ module Spree
       master || build_master
     end
 
-    MASTER_ATTRIBUTES = [:sku, :price, :currency, :display_amount, :display_price, :weight, :height, :width, :depth, :cost_currency, :price_in, :amount_in, :cost_price]
+    MASTER_ATTRIBUTES = [:sku, :price, :currency, :display_amount, :display_price, :weight, :height, :width, :depth, :cost_currency, :price_in, :price_for, :amount_in, :cost_price]
     MASTER_ATTRIBUTES.each do |attr|
       delegate :"#{attr}", :"#{attr}=", to: :find_or_build_master
     end
@@ -161,12 +161,16 @@ module Spree
 
     # Groups variants by the specified option type.
     #
+    # @deprecated This method is not called in the Solidus codebase
     # @param opt_type [String] the name of the option type to group by
+    # @param pricing_options [Spree::Config.pricing_options_class] the pricing options to search
+    #   for, default: the default pricing options
     # @return [Hash] option_type as keys, array of variants as values.
-    def categorise_variants_from_option(opt_type)
+    def categorise_variants_from_option(opt_type, pricing_options = Spree::Config.default_pricing_options)
       return {} unless option_types.include?(opt_type)
-      variants.active.group_by { |v| v.option_values.detect { |o| o.option_type == opt_type} }
+      variants.with_prices(pricing_options).group_by { |v| v.option_values.detect { |o| o.option_type == opt_type } }
     end
+    deprecate :categorise_variants_from_option, deprecator: Spree::Deprecation
 
     # Poor man's full text search.
     #
@@ -184,12 +188,24 @@ module Spree
     end
 
     # @param current_currency [String] currency to filter variants by; defaults to Spree's default
+    # @deprecated This method can only handle prices for currencies
     # @return [Array<Spree::Variant>] all variants with at least one option value
     def variants_and_option_values(current_currency = nil)
       variants.includes(:option_values).active(current_currency).select do |variant|
         variant.option_values.any?
       end
     end
+    deprecate variants_and_option_values: :variants_and_option_values_for,
+              deprecator: Spree::Deprecation
+
+    # @param pricing_options [Spree::Variant::PricingOptions] the pricing options to search
+    #   for, default: the default pricing options
+    # @return [Array<Spree::Variant>] all variants with at least one option value
+    def variants_and_option_values_for(pricing_options = Spree::Config.default_pricing_options)
+      variants.includes(:option_values).with_prices(pricing_options).select do |variant|
+        variant.option_values.any?
+      end
+    end
 
     # Groups all of the option values that are associated to the product's variants, grouped by
     # option type.
@@ -199,10 +215,10 @@ module Spree
     # @return [Hash<Spree::OptionType, Array<Spree::OptionValue>>] all option types and option values
     # associated with the products variants grouped by option type
     def variant_option_values_by_option_type(variant_scope = nil)
-      option_value_ids = Spree::OptionValuesVariant.joins(:variant)
-        .where(spree_variants: { product_id: self.id})
-        .merge(variant_scope)
-        .distinct.pluck(:option_value_id)
+      option_value_scope = Spree::OptionValuesVariant.joins(:variant)
+        .where(spree_variants: { product_id: id })
+      option_value_scope = option_value_scope.merge(variant_scope) if variant_scope
+      option_value_ids = option_value_scope.distinct.pluck(:option_value_id)
       Spree::OptionValue.where(id: option_value_ids).
         includes(:option_type).
         order("#{Spree::OptionType.table_name}.position, #{Spree::OptionValue.table_name}.position").
@@ -319,14 +335,15 @@ module Spree
     end
 
     def punch_slug
-      update_column :slug, "#{Time.current.to_i}_#{slug}" # punch slug with date prefix to allow reuse of original
+      # punch slug with date prefix to allow reuse of original
+      update_column :slug, "#{Time.current.to_i}_#{slug}" unless frozen?
     end
 
     # If the master is invalid, the Product object will be assigned its errors
     def validate_master
       unless master.valid?
         master.errors.each do |att, error|
-          self.errors.add(att, error)
+          errors.add(att, error)
         end
       end
     end
@@ -354,7 +371,7 @@ module Spree
 
     def remove_taxon(taxon)
       removed_classifications = classifications.where(taxon: taxon)
-      removed_classifications.each &:remove_from_list
+      removed_classifications.each(&:remove_from_list)
     end
   end
 end

data/app/models/spree/product_property.rb

@@ -2,6 +2,8 @@ module Spree
   class ProductProperty < Spree::Base
     include Spree::OrderedPropertyValueList
 
+    acts_as_list scope: :product
+
     belongs_to :product, touch: true, class_name: 'Spree::Product', inverse_of: :product_properties
     belongs_to :property, class_name: 'Spree::Property', inverse_of: :product_properties
 

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

@@ -1,45 +1,45 @@
 module Spree
   class ProductScope < Spree::Base
-    before_validation(:on => :create) do
+    before_validation(on: :create) do
       # Add default empty arguments so scope validates and errors aren't caused when previewing it
       if name && args = self.class.arguments_for_scope_name(name)
-        self.arguments ||= ['']*args.length
+        self.arguments ||= [''] * args.length
       end
     end
 
     def self.all_scopes
       {
         # Scopes for selecting products based on taxon
-        :taxon => {
-          :taxons_name_eq => [:taxon_name],
-          :in_taxons => [:taxon_names],
+        taxon: {
+          taxons_name_eq: [:taxon_name],
+          in_taxons: [:taxon_names]
         },
         # product selection based on name, or search
-        :search => {
-          :in_name => [:words],
-          :in_name_or_keywords => [:words],
-          :in_name_or_description => [:words],
-          :with_ids => [:ids]
+        search: {
+          in_name: [:words],
+          in_name_or_keywords: [:words],
+          in_name_or_description: [:words],
+          with_ids: [:ids]
         },
         # Scopes for selecting products based on option types and properties
-        :values => {
-          :with => [:value],
-          :with_property => [:property],
-          :with_property_value => [:property, :value],
-          :with_option => [:option],
-          :with_option_value => [:option, :value],
+        values: {
+          with: [:value],
+          with_property: [:property],
+          with_property_value: [:property, :value],
+          with_option: [:option],
+          with_option_value: [:option, :value]
         },
         # product selection based upon master price
-        :price => {
-          :price_between => [:low, :high],
-          :master_price_lte => [:amount],
-          :master_price_gte => [:amount],
-        },
+        price: {
+          price_between: [:low, :high],
+          master_price_lte: [:amount],
+          master_price_gte: [:amount]
+        }
       }
     end
 
     def self.arguments_for_scope_name(name)
-      if group = all_scopes.detect { |k,v| v[name.to_sym] }
+      if group = all_scopes.detect { |_k, v| v[name.to_sym] }
         group[1][name.to_sym]
       end
     end

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

@@ -22,7 +22,6 @@ module Spree
           return if promotion_credit_exists?(order)
 
           amount = compute_amount(order)
-          return if amount == 0
           Spree::Adjustment.create!(
             amount: amount,
             order: order,
@@ -37,7 +36,7 @@ module Spree
         # Ensure a negative amount which does not exceed the sum of the order's
         # item_total and ship_total
         def compute_amount(calculable)
-          amount = self.calculator.compute(calculable).to_f.abs
+          amount = calculator.compute(calculable).to_f.abs
           [(calculable.item_total + calculable.ship_total), amount].min * -1
         end
 
@@ -50,11 +49,11 @@ module Spree
         # Receives an adjustment +source+ (here a PromotionAction object) and tells
         # if the order has adjustments from that already
         def promotion_credit_exists?(adjustable)
-          self.adjustments.where(adjustable_id: adjustable.id).exists?
+          adjustments.where(adjustable_id: adjustable.id).exists?
         end
 
         def ensure_action_has_calculator
-          return if self.calculator
+          return if calculator
           self.calculator = Calculator::FlatPercentItemTotal.new
         end
       end

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

@@ -23,7 +23,7 @@ module Spree
             current_result = create_adjustment(line_item, order, promotion_code)
             result ||= current_result
           end
-          return result
+          result
         end
 
         # Ensure a negative amount which does not exceed the sum of the order's
@@ -31,21 +31,21 @@ module Spree
         def compute_amount(adjustable)
           order = adjustable.is_a?(Order) ? adjustable : adjustable.order
           return 0 unless promotion.line_item_actionable?(order, adjustable)
-          promotion_amount = self.calculator.compute(adjustable).to_f.abs
+          promotion_amount = calculator.compute(adjustable).to_f.abs
           [adjustable.amount, promotion_amount].min * -1
         end
 
         private
 
         def create_adjustment(adjustable, order, promotion_code)
-          amount = self.compute_amount(adjustable)
+          amount = compute_amount(adjustable)
           return if amount == 0
-          self.adjustments.create!(
+          adjustments.create!(
             amount: amount,
             adjustable: adjustable,
             order: order,
             promotion_code: promotion_code,
-            label: "#{Spree.t(:promotion)} (#{promotion.name})",
+            label: "#{Spree.t(:promotion)} (#{promotion.name})"
           )
           true
         end
@@ -57,16 +57,16 @@ module Spree
         # Receives an adjustment +source+ (here a PromotionAction object) and tells
         # if the order has adjustments from that already
         def promotion_credit_exists?(adjustable)
-          self.adjustments.where(adjustable_id: adjustable.id).exists?
+          adjustments.where(adjustable_id: adjustable.id).exists?
         end
 
         def ensure_action_has_calculator
-          return if self.calculator
+          return if calculator
           self.calculator = Calculator::PercentOnLineItem.new
         end
 
         def line_items_to_adjust(promotion, order)
-          excluded_ids = self.adjustments.
+          excluded_ids = adjustments.
             where(adjustable_id: order.line_items.pluck(:id), adjustable_type: 'Spree::LineItem').
             pluck(:adjustable_id)
 

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

@@ -59,7 +59,7 @@ module Spree::Promotion::Actions
       order = line_item.order
       line_items = actionable_line_items(order)
 
-      actioned_line_items = order.line_item_adjustments(true).
+      actioned_line_items = order.line_item_adjustments.reload.
         select { |a| a.source == self && a.amount < 0 }.
         map(&:adjustable)
       other_line_items = actioned_line_items - [line_item]
@@ -71,7 +71,7 @@ module Spree::Promotion::Actions
         line_item.quantity
       ].min
 
-      persist_quantity(usable_quantity,  line_item)
+      persist_quantity(usable_quantity, line_item)
 
       amount = adjustment_amount * usable_quantity
       [line_item.amount, amount].min * -1
@@ -80,7 +80,7 @@ module Spree::Promotion::Actions
     private
 
     def actionable_line_items(order)
-      order.line_items(true).select do |item|
+      order.line_items.reload.select do |item|
         promotion.line_item_actionable? order, item
       end
     end

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

@@ -2,7 +2,7 @@ module Spree
   class Promotion
     module Actions
       class FreeShipping < Spree::PromotionAction
-        def perform(payload={})
+        def perform(payload = {})
           order = payload[:order]
           promotion_code = payload[:promotion_code]
 
@@ -13,7 +13,7 @@ module Spree
               amount: compute_amount(shipment),
               source: self,
               promotion_code: promotion_code,
-              label: label,
+              label: label
             )
             true
           end
@@ -33,9 +33,9 @@ module Spree
         private
 
         def promotion_credit_exists?(shipment)
-          shipment.adjustments.where(:source_id => self.id).exists?
+          shipment.adjustments.where(source_id: id).exists?
         end
       end
     end
   end
-end
+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/first_repeat_purchase_since.rb

@@ -15,7 +15,7 @@ module Spree
         # This is eligible if the user's most recently completed order is more than the preferred days ago
         # @param order [Spree::Order]
         # @option options
-        def eligible?(order, options = {})
+        def eligible?(order, _options = {})
           return false unless order.user
 
           last_order = last_completed_order(order.user)
@@ -26,11 +26,10 @@ module Spree
 
         private
 
-        def last_completed_order user
+        def last_completed_order(user)
           user.orders.complete.order(:completed_at).last
         end
       end
     end
   end
 end
-

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

@@ -5,6 +5,7 @@ module Spree
       # a specific amount
       class ItemTotal < PromotionRule
         preference :amount, :decimal, default: 100.00
+        preference :currency, :string, default: ->{ Spree::Config[:currency] }
         preference :operator, :string, default: '>'
 
         OPERATORS = ['gt', 'gte']
@@ -13,7 +14,8 @@ module Spree
           promotable.is_a?(Spree::Order)
         end
 
-        def eligible?(order, options = {})
+        def eligible?(order, _options = {})
+          return false unless order.currency == preferred_currency
           item_total = order.item_total
           unless item_total.send(preferred_operator == 'gte' ? :>= : :>, BigDecimal.new(preferred_amount.to_s))
             eligibility_errors.add(:base, ineligible_message)
@@ -23,8 +25,9 @@ module Spree
         end
 
         private
+
         def formatted_amount
-          Spree::Money.new(preferred_amount).to_s
+          Spree::Money.new(preferred_amount, currency: preferred_currency).to_s
         end
 
         def ineligible_message

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

@@ -17,7 +17,7 @@ module Spree
         # Use the first order rule if you want a promotion to be applied to the first order for a user.
         # @param order [Spree::Order]
         # @option options
-        def eligible?(order, options = {})
+        def eligible?(order, _options = {})
           return false unless order.user
 
           nth_order?(order)
@@ -25,7 +25,7 @@ module Spree
 
         private
 
-        def completed_order_count order
+        def completed_order_count(order)
           order.
             user.
             orders.
@@ -34,7 +34,7 @@ module Spree
             count
         end
 
-        def nth_order? order
+        def nth_order?(order)
           count = completed_order_count(order) + 1
           count == preferred_nth_order
         end
@@ -42,4 +42,3 @@ module Spree
     end
   end
 end
-

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

@@ -6,7 +6,7 @@ module Spree
           promotable.is_a?(Spree::Order)
         end
 
-        def eligible?(order, options = {})
+        def eligible?(order, _options = {})
           if order.user.present?
             if promotion.used_by?(order.user, [order])
               eligibility_errors.add(:base, eligibility_error_message(:limit_once_per_user))
@@ -21,4 +21,3 @@ module Spree
     end
   end
 end
-

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

@@ -10,7 +10,7 @@ module Spree
           promotable.is_a?(Spree::Order)
         end
 
-        def eligible?(promotable, options = {})
+        def eligible?(promotable, _options = {})
           case preferred_match_policy
           when 'any'
             promotable.line_items.any? { |item| actionable?(item) }
@@ -18,7 +18,6 @@ module Spree
         end
 
         def actionable?(line_item)
-
           pid = line_item.product.id
           ovids = line_item.variant.option_values.pluck(:id)
 

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

@@ -22,19 +22,19 @@ module Spree
           promotable.is_a?(Spree::Order)
         end
 
-        def eligible?(order, options = {})
+        def eligible?(order, _options = {})
           return true if eligible_products.empty?
 
           if preferred_match_policy == 'all'
-            unless eligible_products.all? {|p| order.products.include?(p) }
+            unless eligible_products.all? { |p| order.products.include?(p) }
               eligibility_errors.add(:base, eligibility_error_message(:missing_product))
             end
           elsif preferred_match_policy == 'any'
-            unless order.products.any? {|p| eligible_products.include?(p) }
+            unless order.products.any? { |p| eligible_products.include?(p) }
               eligibility_errors.add(:base, eligibility_error_message(:no_applicable_products))
             end
           else
-            unless order.products.none? {|p| eligible_products.include?(p) }
+            unless order.products.none? { |p| eligible_products.include?(p) }
               eligibility_errors.add(:base, eligibility_error_message(:has_excluded_product))
             end
           end

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

@@ -12,7 +12,7 @@ module Spree
           promotable.is_a?(Spree::Order)
         end
 
-        def eligible?(order, options = {})
+        def eligible?(order, _options = {})
           if preferred_match_policy == 'all'
             unless (taxons.to_a - taxons_in_order_including_parents(order)).empty?
               eligibility_errors.add(:base, eligibility_error_message(:missing_taxon))
@@ -44,12 +44,12 @@ module Spree
 
         # All taxons in an order
         def order_taxons(order)
-          Spree::Taxon.joins(products: {variants_including_master: :line_items}).where(spree_line_items: {order_id: order.id}).uniq
+          Spree::Taxon.joins(products: { variants_including_master: :line_items }).where(spree_line_items: { order_id: order.id }).distinct
         end
 
         # ids of taxons rules and taxons rules children
         def taxons_including_children_ids
-          taxons.inject([]){ |ids,taxon| ids += taxon.self_and_descendants.ids }
+          taxons.flat_map { |taxon| taxon.self_and_descendants.ids }
         end
 
         # taxons order vs taxons rules and taxons rules children
@@ -58,11 +58,11 @@ module Spree
         end
 
         def taxons_in_order_including_parents(order)
-          order_taxons_in_taxons_and_children(order).inject([]){ |taxons, taxon| taxons << taxon.self_and_ancestors }.flatten.uniq
+          order_taxons_in_taxons_and_children(order).flat_map(&:self_and_ancestors).uniq
         end
 
         def taxon_product_ids
-          Spree::Product.joins(:taxons).where(spree_taxons: {id: taxons.pluck(:id)}).pluck(:id).uniq
+          Spree::Product.joins(:taxons).where(spree_taxons: { id: taxons.pluck(:id) }).pluck(:id).uniq
         end
       end
     end

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

@@ -12,7 +12,7 @@ module Spree
           promotable.is_a?(Spree::Order)
         end
 
-        def eligible?(order, options = {})
+        def eligible?(order, _options = {})
           users.include?(order.user)
         end
 

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

@@ -6,7 +6,7 @@ module Spree
           promotable.is_a?(Spree::Order)
         end
 
-        def eligible?(order, options = {})
+        def eligible?(order, _options = {})
           unless order.user.present?
             eligibility_errors.add(:base, eligibility_error_message(:no_user_specified))
           end

data/app/models/spree/promotion.rb

@@ -35,12 +35,12 @@ module Spree
     scope :coupons, -> { where.not(code: nil) }
     scope :advertised, -> { where(advertise: true) }
     scope :active, -> do
-      table = self.arel_table
+      table = arel_table
       time = Time.current
       where(table[:starts_at].eq(nil).or(table[:starts_at].lt(time))).
         where(table[:expires_at].eq(nil).or(table[:expires_at].gt(time)))
     end
-    scope :applied, -> { joins(:order_promotions).uniq }
+    scope :applied, -> { joins(:order_promotions).distinct }
 
     self.whitelisted_ransackable_associations = ['codes']
     self.whitelisted_ransackable_attributes = ['path', 'promotion_category_id']
@@ -58,7 +58,7 @@ module Spree
       raise "Attempted to call code on a Spree::Promotion. Promotions are now tied to multiple code records"
     end
 
-    def code=(val)
+    def code=(_val)
       raise "Attempted to call code= on a Spree::Promotion. Promotions are now tied to multiple code records"
     end
 
@@ -68,7 +68,7 @@ module Spree
       ).first
     end
 
-    def as_json(options={})
+    def as_json(options = {})
       options[:except] ||= :code
       super
     end
@@ -91,7 +91,7 @@ module Spree
         line_item: line_item,
         user: user,
         path: path,
-        promotion_code: promotion_code,
+        promotion_code: promotion_code
       }
 
       # Track results from actions to see if any action has been taken.
@@ -107,11 +107,11 @@ module Spree
         # connect to the order
         order_promotions.find_or_create_by!(
           order_id: order.id,
-          promotion_code_id: promotion_code.try!(:id),
+          promotion_code_id: promotion_code.try!(:id)
         )
       end
 
-      return action_taken
+      action_taken
     end
 
     # called anytime order.update! happens
@@ -218,7 +218,7 @@ module Spree
         !promotable.product.promotionable?
       when Spree::Order
         promotable.line_items.any? &&
-          promotable.line_items.joins(:product).where(spree_products: {promotionable: false}).any?
+          promotable.line_items.joins(:product).where(spree_products: { promotionable: false }).any?
       end
     end
 

data/app/models/spree/promotion_action.rb

@@ -16,7 +16,7 @@ module Spree
     # user based actions to be performed in addition to actions on the order
     #
     # @note This method should be overriden in subclassses.
-    def perform(options = {})
+    def perform(_options = {})
       raise 'perform should be implemented in a sub-class of PromotionAction'
     end
   end

data/app/models/spree/promotion_builder.rb

@@ -16,7 +16,7 @@ class Spree::PromotionBuilder
   # @param promotion_attrs [Hash] The desired attributes for the newly promotion
   # @param attributes [Hash] The desired attributes for this builder
   # @param user [Spree::User] The user who triggered this promotion build
-  def initialize(attributes={}, promotion_attributes={})
+  def initialize(attributes = {}, promotion_attributes = {})
     @promotion = Spree::Promotion.new(promotion_attributes)
     super(attributes)
   end
@@ -31,7 +31,7 @@ class Spree::PromotionBuilder
     @promotion.save
   end
 
-  def number_of_codes= value
+  def number_of_codes=(value)
     @number_of_codes = value.presence.try(:to_i)
   end
 

data/app/models/spree/promotion_chooser.rb

@@ -21,6 +21,7 @@ module Spree
     end
 
     private
+
     # @return The best promotion from this set of adjustments.
     def best_promotion_adjustment
       @best_promotion_adjustment ||= @adjustments.select(&:eligible?).min_by do |a|

data/app/models/spree/promotion_code/code_builder.rb

@@ -10,7 +10,7 @@ class ::Spree::PromotionCode::CodeBuilder
   # +promotion+ Must be a Spree::Promotion.
   # +base_code+ Must be a String.
   # +num_codes+ Must be a positive integer greater than zero.
-  def initialize promotion, base_code, num_codes
+  def initialize(promotion, base_code, num_codes)
     @base_code = base_code
     @num_codes = num_codes
     @promotion = promotion
@@ -36,8 +36,8 @@ class ::Spree::PromotionCode::CodeBuilder
   def generate_random_codes
     valid_codes = Set.new
 
-    while valid_codes.size < num_codes do
-      new_codes = num_codes.times.map { generate_random_code }.to_set
+    while valid_codes.size < num_codes
+      new_codes = Array.new(num_codes) { generate_random_code }.to_set
       valid_codes += get_unique_codes(new_codes)
     end