solidus_core 1.2.3 → 1.3.0.beta1

data/app/models/spree/validations/db_maximum_length_validator.rb

@@ -3,7 +3,6 @@ module Spree
     ##
     # Validates a field based on the maximum length of the underlying DB field, if there is one.
     class DbMaximumLengthValidator < ActiveModel::Validator
-
       def initialize(options)
         super
         @field = options[:field].to_s

data/app/models/spree/variant/pricer.rb

@@ -0,0 +1,19 @@
+module Spree
+  class Variant
+    class Pricer
+      def self.pricing_options_class
+        Spree::Variant::PricingOptions
+      end
+
+      attr_reader :variant
+
+      def initialize(variant)
+        @variant = variant
+      end
+
+      def price_for(price_options)
+        variant.prices.currently_valid.find_by(price_options.desired_attributes).try!(:money)
+      end
+    end
+  end
+end

data/app/models/spree/variant/pricing_options.rb

@@ -0,0 +1,31 @@
+module Spree
+  class Variant
+    class PricingOptions
+      def self.default_price_attributes
+        { currency: Spree::Config.currency }
+      end
+
+      def self.from_line_item(line_item)
+        new(currency: line_item.order.try(:currency) || line_item.currency || Spree::Config.currency )
+      end
+
+      def self.from_price(price)
+        new(currency: price.currency)
+      end
+
+      attr_reader :desired_attributes
+
+      def initialize(desired_attributes = {})
+        @desired_attributes = self.class.default_price_attributes.merge(desired_attributes)
+      end
+
+      def currency
+        desired_attributes[:currency]
+      end
+
+      def cache_key
+        desired_attributes.values.map(&:to_s).join("/")
+      end
+    end
+  end
+end

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

@@ -1,6 +1,6 @@
 module Spree
   class Variant < Spree::Base
-    #FIXME WARNING tested only under sqlite and postgresql
+    # FIXME: WARNING tested only under sqlite and postgresql
     scope :descend_by_popularity, -> {
       order("COALESCE((SELECT COUNT(*) FROM  #{LineItem.quoted_table_name} GROUP BY #{LineItem.quoted_table_name}.variant_id HAVING #{LineItem.quoted_table_name}.variant_id = #{Variant.quoted_table_name}.id), 0) DESC")
     }
@@ -15,18 +15,18 @@ module Spree
         option_types = OptionType.table_name
 
         option_type_conditions = case option_type
-        when OptionType then { "#{option_types}.name" => option_type.name }
-        when String     then { "#{option_types}.name" => option_type }
-        else                 { "#{option_types}.id"   => option_type }
+                                 when OptionType then { "#{option_types}.name" => option_type.name }
+                                 when String     then { "#{option_types}.name" => option_type }
+        else { "#{option_types}.id" => option_type }
         end
 
-        relation = joins(:option_values => :option_type).where(option_type_conditions)
+        relation = joins(option_values: :option_type).where(option_type_conditions)
 
-        option_values_conditions = option_values.each do |option_value|
+        option_values.each do |option_value|
           option_value_conditions = case option_value
-          when OptionValue then { "#{OptionValue.table_name}.name" => option_value.name }
-          when String      then { "#{OptionValue.table_name}.name" => option_value }
-          else                  { "#{OptionValue.table_name}.id"   => option_value }
+                                    when OptionValue then { "#{OptionValue.table_name}.name" => option_value.name }
+                                    when String      then { "#{OptionValue.table_name}.name" => option_value }
+          else { "#{OptionValue.table_name}.id" => option_value }
           end
           relation = relation.where(option_value_conditions)
         end

data/app/models/spree/variant.rb

@@ -15,6 +15,7 @@ module Spree
   # inventory level determine "on_hand" level for the product.
   class Variant < Spree::Base
     acts_as_paranoid
+    acts_as_list scope: :product
 
     include Spree::DefaultPrice
 
@@ -24,6 +25,7 @@ module Spree
     delegate :name, :description, :slug, :available_on, :shipping_category_id,
              :meta_description, :meta_keywords, :shipping_category,
              to: :product
+    delegate :tax_category, to: :product, prefix: true
 
     has_many :inventory_units, inverse_of: :variant
     has_many :line_items, inverse_of: :variant
@@ -33,7 +35,7 @@ module Spree
     has_many :stock_locations, through: :stock_items
     has_many :stock_movements, through: :stock_items
 
-    has_many :option_values_variants, dependent: :destroy
+    has_many :option_values_variants
     has_many :option_values, through: :option_values_variants
 
     has_many :images, -> { order(:position) }, as: :viewable, dependent: :destroy, class_name: "Spree::Image"
@@ -57,6 +59,8 @@ module Spree
 
     after_touch :clear_in_stock_cache
 
+    after_real_destroy :destroy_option_values_variants
+
     # Returns variants that are in stock. When stock locations are provided as
     # a parameter, the scope is limited to variants that are in stock in the
     # provided stock locations.
@@ -64,6 +68,7 @@ module Spree
     # @param stock_locations [Array<Spree::StockLocation>] the stock locations to check
     # @return [ActiveRecord::Relation]
     def self.in_stock(stock_locations = nil)
+      return all unless Spree::Config.track_inventory_levels
       in_stock_variants = joins(:stock_items).where(Spree::StockItem.arel_table[:count_on_hand].gt(0).or(arel_table[:track_inventory].eq(false)))
       if stock_locations.present?
         in_stock_variants = in_stock_variants.where(spree_stock_items: { stock_location_id: stock_locations.map(&:id) })
@@ -83,13 +88,21 @@ module Spree
       joins(:prices).where(deleted_at: nil).where('spree_prices.currency' => currency || Spree::Config[:currency]).where('spree_prices.amount IS NOT NULL')
     end
 
+    # Returns variants that have a price for the given pricing options
+    #
+    # @param pricing_options A Pricing Options object as defined on the pricer class
+    # @return [ActiveRecord::Relation]
+    def self.with_prices(pricing_options = Spree::Config.default_pricing_options)
+      joins(:prices).merge(Spree::Price.currently_valid.where(pricing_options.desired_attributes))
+    end
+
     # @return [Spree::TaxCategory] the variant's tax category
+    #
+    # This returns the product's tax category if the tax category ID on the variant is nil. It looks
+    # like an association, but really is an override.
+    #
     def tax_category
-      if self[:tax_category_id].nil?
-        product.tax_category
-      else
-        TaxCategory.find(self[:tax_category_id])
-      end
+      super || product_tax_category
     end
 
     # Sets the cost_price for the variant.
@@ -124,7 +137,7 @@ module Spree
     #
     # @return [String] a sentence-ified string of option values.
     def options_text
-      values = self.option_values.includes(:option_type).sort_by do |option_value|
+      values = option_values.includes(:option_type).sort_by do |option_value|
         option_value.option_type.position
       end
 
@@ -173,22 +186,22 @@ module Spree
     # @param opt_value [String] the value to set to the option
     def set_option_value(opt_name, opt_value)
       # no option values on master
-      return if self.is_master
+      return if is_master
 
       option_type = Spree::OptionType.where(name: opt_name).first_or_initialize do |o|
         o.presentation = opt_name
         o.save!
       end
 
-      current_value = self.option_values.detect { |o| o.option_type.name == opt_name }
+      current_value = option_values.detect { |o| o.option_type.name == opt_name }
 
-      unless current_value.nil?
+      if current_value
         return if current_value.name == opt_value
-        self.option_values.delete(current_value)
+        option_values.delete(current_value)
       else
         # then we have to check to make sure that the product has the option type
-        unless self.product.option_types.include? option_type
-          self.product.option_types << option_type
+        unless product.option_types.include? option_type
+          product.option_types << option_type
         end
       end
 
@@ -197,8 +210,8 @@ module Spree
         o.save!
       end
 
-      self.option_values << option_value
-      self.save
+      option_values << option_value
+      save
     end
 
     # Fetches the option value for the given option name.
@@ -206,7 +219,35 @@ module Spree
     # @param opt_name [String] the name of the option whose value you want
     # @return [String] the option value
     def option_value(opt_name)
-      self.option_values.detect { |o| o.option_type.name == opt_name }.try(:presentation)
+      option_values.detect { |o| o.option_type.name == opt_name }.try(:presentation)
+    end
+
+    # Returns an instance of the globally configured variant pricer class for this variant.
+    # It's cached so we don't create too many objects.
+    #
+    # @return [Spree::Variant::Pricer] The default pricer class
+    def pricer
+      @pricer ||= Spree::Config.variant_pricer_class.new(self)
+    end
+
+    # Chooses an appropriate price for the given pricing options
+    #
+    # @see Spree::Variant::Pricer#price_for
+    # @param [Spree::Config.pricing_options_class] An instance of pricing options
+    # @return [Spree::Money] The chosen price as a Money object
+    delegate :price_for, to: :pricer
+
+    # Returns the difference in price from the master variant
+    def price_difference_from_master(pricing_options = Spree::Config.default_pricing_options)
+      master_price = product.master.price_for(pricing_options)
+      variant_price = price_for(pricing_options)
+      return unless master_price && variant_price
+      variant_price - master_price
+    end
+
+    def price_same_as_master?(pricing_options = Spree::Config.default_pricing_options)
+      diff = price_difference_from_master(pricing_options)
+      diff && diff.zero?
     end
 
     # Converts the variant's price to the given currency.
@@ -214,7 +255,7 @@ module Spree
     # @param currency [String] the desired currency
     # @return [Spree::Price] the price in the desired currency
     def price_in(currency)
-      prices.detect{ |price| price.currency == currency && price.is_default } || Spree::Price.new(variant_id: self.id, currency: currency)
+      prices.currently_valid.find_by(currency: currency)
     end
 
     # Fetches the price amount in the specified currency.
@@ -225,42 +266,6 @@ module Spree
       price_in(currency).try(:amount)
     end
 
-    # Calculates the sum of the specified price modifiers in the specified
-    # currency.
-    #
-    # @param currency [String] (see #price)
-    # @param options (see #price_modifier_amount)
-    # @return (see #price_modifier_amount)
-    def price_modifier_amount_in(currency, options = {})
-      return 0 unless options.present?
-
-      options.keys.map { |key|
-        m = "#{key}_price_modifier_amount_in".to_sym
-        if self.respond_to? m
-          self.send(m, currency, options[key])
-        else
-          0
-        end
-      }.sum
-    end
-
-    # Calculates the sum of the specified price modifiers.
-    #
-    # @param options [Hash] for specifying keys, eg: `{keys: ['key_1', 'key_2']}`
-    # @return [Fixnum] the sum
-    def price_modifier_amount(options = {})
-      return 0 unless options.present?
-
-      options.keys.map { |key|
-        m = "#{options[key]}_price_modifier_amount".to_sym
-        if self.respond_to? m
-          self.send(m, options[key])
-        else
-          0
-        end
-      }.sum
-    end
-
     # Generates a friendly name and sku string.
     #
     # @return [String]
@@ -284,7 +289,7 @@ module Spree
 
     # @param quantity [Fixnum] how many are desired
     # @return [Boolean] true if the desired quantity can be supplied
-    def can_supply?(quantity=1)
+    def can_supply?(quantity = 1)
       Spree::Stock::Quantifier.new(self).can_supply?(quantity)
     end
 
@@ -301,7 +306,7 @@ module Spree
     #
     # @return [Boolean] true if inventory tracking is enabled
     def should_track_inventory?
-      self.track_inventory? && Spree::Config.track_inventory_levels
+      track_inventory? && Spree::Config.track_inventory_levels
     end
 
     # Image that can be used for the variant.
@@ -321,56 +326,57 @@ module Spree
     #
     # @return [Array<Spree::VariantPropertyRuleValue>] variant_properties
     def variant_properties
-      self.product.variant_property_rules.map do |rule|
+      product.variant_property_rules.map do |rule|
         rule.values if rule.applies_to_variant?(self)
       end.flatten.compact
     end
 
     private
 
-      def set_master_out_of_stock
-        if product.master && product.master.in_stock?
-          product.master.stock_items.update_all(:backorderable => false)
-          product.master.stock_items.each { |item| item.reduce_count_on_hand_to_zero }
-        end
+    def set_master_out_of_stock
+      if product.master && product.master.in_stock?
+        product.master.stock_items.update_all(backorderable: false)
+        product.master.stock_items.each(&:reduce_count_on_hand_to_zero)
       end
+    end
 
-      # Ensures a new variant takes the product master price when price is not supplied
-      def check_price
-        if price.nil? && Spree::Config[:require_master_price]
-          if is_master?
-            errors.add :price, 'Must supply price for variant or master.price for product.'
-          else
-            raise 'No master variant found to infer price' unless (product && product.master)
-            self.price = product.master.price
-          end
-        end
-        if currency.nil?
-          self.currency = Spree::Config[:currency]
+    # Ensures a new variant takes the product master price when price is not supplied
+    def check_price
+      if price.nil? && Spree::Config[:require_master_price]
+        if is_master?
+          errors.add :price, 'Must supply price for variant or master.price for product.'
+        else
+          raise 'No master variant found to infer price' unless product && product.master
+          self.price = product.master.price
         end
       end
+    end
 
-      def set_cost_currency
-        self.cost_currency = Spree::Config[:currency] if cost_currency.blank?
-      end
+    def set_cost_currency
+      self.cost_currency = Spree::Config[:currency] if cost_currency.blank?
+    end
 
-      def create_stock_items
-        StockLocation.where(propagate_all_variants: true).each do |stock_location|
-          stock_location.propagate_variant(self)
-        end
+    def create_stock_items
+      StockLocation.where(propagate_all_variants: true).each do |stock_location|
+        stock_location.propagate_variant(self)
       end
+    end
 
-      def set_position
-        self.update_column(:position, product.variants.maximum(:position).to_i + 1)
-      end
+    def set_position
+      update_column(:position, product.variants.maximum(:position).to_i + 1)
+    end
 
-      def in_stock_cache_key
-        "variant-#{id}-in_stock"
-      end
+    def in_stock_cache_key
+      "variant-#{id}-in_stock"
+    end
 
-      def clear_in_stock_cache
-        Rails.cache.delete(in_stock_cache_key)
-      end
+    def clear_in_stock_cache
+      Rails.cache.delete(in_stock_cache_key)
+    end
+
+    def destroy_option_values_variants
+      option_values_variants.destroy_all
+    end
   end
 end
 

data/app/models/spree/variant_property_rule.rb

@@ -36,7 +36,7 @@ module Spree
     # @param variant [Spree::Variant] variant to check
     # @return [Boolean]
     def applies_to_variant?(variant)
-      (self.option_value_ids & variant.option_value_ids).present?
+      (option_value_ids & variant.option_value_ids).present?
     end
   end
 end

data/app/models/spree/variant_property_rule_value.rb

@@ -2,6 +2,8 @@ module Spree
   class VariantPropertyRuleValue < Spree::Base
     include Spree::OrderedPropertyValueList
 
+    acts_as_list scope: :variant_property_rule
+
     belongs_to :property
     belongs_to :variant_property_rule, touch: true
   end

data/app/models/spree/zone.rb

@@ -15,6 +15,27 @@ module Spree
     after_save :remove_defunct_members
     after_save :remove_previous_default
 
+    scope :with_member_ids, ->(state_ids, country_ids) do
+      return none if !state_ids.present? && !country_ids.present?
+
+      spree_zone_members_table = Spree::ZoneMember.arel_table
+      matching_state =
+        spree_zone_members_table[:zoneable_type].eq("Spree::State").
+        and(spree_zone_members_table[:zoneable_id].in(state_ids))
+      matching_country =
+        spree_zone_members_table[:zoneable_type].eq("Spree::Country").
+        and(spree_zone_members_table[:zoneable_id].in(country_ids))
+      joins(:zone_members).where(matching_state.or(matching_country)).distinct
+    end
+
+    scope :for_address, ->(address) do
+      if address
+        with_member_ids(address.state_id, address.country_id)
+      else
+        none
+      end
+    end
+
     alias :members :zone_members
     accepts_nested_attributes_for :zone_members, allow_destroy: true, reject_if: proc { |a| a['zoneable_id'].blank? }
 
@@ -24,13 +45,14 @@ module Spree
       where(default_tax: true).first
     end
 
-    # Returns the matching zone with the highest priority zone type (State, Country, Zone.)
-    # Returns nil in the case of no matches.
+    # Returns the most specific matching zone for an address. Specific means:
+    # A State zone wins over a country zone, and a zone with few members wins
+    # over one with many members. If there is no match, returns nil.
     def self.match(address)
-      return unless address and matches = self.includes(:zone_members).
-        order(:zone_members_count, :created_at, :id).
-        where("(spree_zone_members.zoneable_type = 'Spree::Country' AND spree_zone_members.zoneable_id = ?) OR (spree_zone_members.zoneable_type = 'Spree::State' AND spree_zone_members.zoneable_id = ?)", address.country_id, address.state_id).
-        references(:zones)
+      return unless address && (matches =
+                                  with_member_ids(address.state_id, address.country_id).
+                                  order(:zone_members_count, :created_at, :id).
+                                  references(:zones))
 
       ['state', 'country'].each do |zone_kind|
         if match = matches.detect { |zone| zone_kind == zone.kind }
@@ -40,6 +62,21 @@ module Spree
       matches.first
     end
 
+    # Returns all zones that contain any of the zone members of the zone passed
+    # in. This also includes any country zones that contain the state of the
+    # current zone, if it's a state zone. If the passed-in zone has members, it
+    # will also be in the result set.
+    def self.with_shared_members(zone)
+      return none unless zone
+
+      states_and_state_country_ids = zone.states.pluck(:id, :country_id).to_a
+      state_ids = states_and_state_country_ids.map(&:first)
+      state_country_ids = states_and_state_country_ids.map(&:second)
+      country_ids = zone.countries.pluck(:id).to_a
+
+      with_member_ids(state_ids, country_ids + state_country_ids).distinct
+    end
+
     def kind
       if members.any? && !members.any? { |member| member.try(:zoneable_type).nil? }
         members.last.zoneable_type.demodulize.underscore
@@ -116,33 +153,32 @@ module Spree
       return false if zone_members.empty? || target.zone_members.empty?
 
       if kind == target.kind
-        return false if (target.zoneables.collect(&:id) - zoneables.collect(&:id)).present?
+        (target.zoneables.collect(&:id) - zoneables.collect(&:id)).empty?
       else
-        return false if (target.zoneables.collect(&:country).collect(&:id) - zoneables.collect(&:id)).present?
+        (target.zoneables.collect(&:country).collect(&:id) - zoneables.collect(&:id)).empty?
       end
-      true
     end
 
     private
 
-      def remove_defunct_members
-        if zone_members.any?
-          zone_members.where('zoneable_id IS NULL OR zoneable_type != ?', "Spree::#{kind.classify}").destroy_all
-        end
+    def remove_defunct_members
+      if zone_members.any?
+        zone_members.where('zoneable_id IS NULL OR zoneable_type != ?', "Spree::#{kind.classify}").destroy_all
       end
+    end
 
-      def remove_previous_default
-        Spree::Zone.where('id != ?', self.id).update_all(default_tax: false) if default_tax
-      end
+    def remove_previous_default
+      Spree::Zone.where('id != ?', id).update_all(default_tax: false) if default_tax
+    end
 
-      def set_zone_members(ids, type)
-        zone_members.destroy_all
-        ids.reject{ |id| id.blank? }.map do |id|
-          member = ZoneMember.new
-          member.zoneable_type = type
-          member.zoneable_id = id
-          members << member
-        end
+    def set_zone_members(ids, type)
+      zone_members.destroy_all
+      ids.reject(&:blank?).map do |id|
+        member = ZoneMember.new
+        member.zoneable_type = type
+        member.zoneable_id = id
+        members << member
       end
+    end
   end
 end

data/config/initializers/friendly_id.rb

@@ -17,7 +17,7 @@ FriendlyId.defaults do |config|
   config.use :reserved
 
   config.reserved_words = %w(new edit index session login logout users admin
-    stylesheets assets javascripts images)
+                             stylesheets assets javascripts images)
 
   #  ## Friendly Finders
   #