spree_core 2.4.10 → 3.0.0.rc1

data/app/models/spree/stock/coordinator.rb

@@ -31,7 +31,7 @@ module Spree
       # Returns an array of Package instances
       def build_packages(packages = Array.new)
         StockLocation.active.each do |stock_location|
-          next unless stock_location.stock_items.where(:variant_id => inventory_units.map(&:variant_id)).exists?
+          next unless stock_location.stock_items.where(:variant_id => inventory_units.map(&:variant_id).uniq).exists?
 
           packer = build_packer(stock_location, inventory_units)
           packages += packer.packages

data/app/models/spree/stock/estimator.rb

@@ -8,9 +8,8 @@ module Spree
         @currency = order.currency
       end
 
-      def shipping_rates(package, frontend_only = true)
-        rates = calculate_shipping_rates(package)
-        rates.select! { |rate| rate.shipping_method.frontend? } if frontend_only
+      def shipping_rates(package, shipping_method_filter = ShippingMethod::DISPLAY_ON_FRONT_END)
+        rates = calculate_shipping_rates(package, shipping_method_filter)
         choose_default_shipping_rate(rates)
         sort_shipping_rates(rates)
       end
@@ -26,8 +25,8 @@ module Spree
         shipping_rates.sort_by!(&:cost)
       end
 
-      def calculate_shipping_rates(package)
-        shipping_methods(package).map do |shipping_method|
+      def calculate_shipping_rates(package, ui_filter)
+        shipping_methods(package, ui_filter).map do |shipping_method|
           cost = shipping_method.calculator.compute(package)
           tax_category = shipping_method.tax_category
           if tax_category
@@ -48,10 +47,11 @@ module Spree
         end.compact
       end
 
-      def shipping_methods(package)
+      def shipping_methods(package, display_filter)
         package.shipping_methods.select do |ship_method|
           calculator = ship_method.calculator
           begin
+            ship_method.available_to_display(display_filter) &&
             ship_method.include?(order.ship_address) &&
             calculator.available?(package) &&
             (calculator.preferences[:currency].blank? ||

data/app/models/spree/stock/quantifier.rb

@@ -5,7 +5,7 @@ module Spree
 
       def initialize(variant)
         @variant = variant
-        @stock_items = Spree::StockItem.joins(:stock_location).where(:variant_id => @variant, Spree::StockLocation.table_name =>{ :active => true})
+        @stock_items = Spree::StockItem.joins(:stock_location).where(variant_id: @variant, Spree::StockLocation.table_name => { active: true })
       end
 
       def total_on_hand

data/app/models/spree/stock_item.rb

@@ -8,19 +8,13 @@ module Spree
 
     validates_presence_of :stock_location, :variant
     validates_uniqueness_of :variant_id, scope: [:stock_location_id, :deleted_at]
-
-    validates_numericality_of :count_on_hand,
-                              greater_than_or_equal_to: 0,
-                              less_than_or_equal_to: 2**31 - 1,
-                              only_integer: true, if: :verify_count_on_hand?
+    validates :count_on_hand, numericality: { greater_than_or_equal_to: 0 }, if: :verify_count_on_hand?
 
     delegate :weight, :should_track_inventory?, to: :variant
 
     after_save :conditional_variant_touch, if: :changed?
     after_touch { variant.touch }
 
-    self.whitelisted_ransackable_attributes = ['count_on_hand', 'stock_location_id']
-
     def backordered_inventory_units
       Spree::InventoryUnit.backordered_for_stock_item(self)
     end

data/app/models/spree/stock_location.rb

@@ -107,7 +107,9 @@ module Spree
 
     private
       def create_stock_items
-        Variant.find_each { |variant| self.propagate_variant(variant) }
+        Variant.includes(:product).find_each do |variant|
+          propagate_variant(variant)
+        end
       end
 
       def ensure_one_default

data/app/models/spree/stock_movement.rb

@@ -6,17 +6,10 @@ module Spree
     after_create :update_stock_item_quantity
 
     validates :stock_item, presence: true
-    validates :quantity, presence: true, numericality: {
-                 greater_than_or_equal_to: -2**31,
-                 less_than_or_equal_to: 2**31-1,
-                 only_integer: true,
-                 allow_nil: true
-              }
+    validates :quantity, presence: true
 
     scope :recent, -> { order('created_at DESC') }
 
-    self.whitelisted_ransackable_attributes = ['quantity']
-
     def readonly?
       !new_record?
     end

data/app/models/spree/stock_transfer.rb

@@ -1,13 +1,19 @@
 module Spree
   class StockTransfer < Spree::Base
-    has_many :stock_movements, :as => :originator
+    extend FriendlyId
+    friendly_id :number, slug_column: :number, use: :slugged
 
-    belongs_to :source_location, :class_name => 'StockLocation'
-    belongs_to :destination_location, :class_name => 'StockLocation'
+    include Spree::NumberGenerator
 
-    make_permalink field: :number, prefix: 'T'
+    def generate_number(options = {})
+      options[:prefix] ||= 'T'
+      super(options)
+    end
+
+    has_many :stock_movements, as: :originator
 
-    self.whitelisted_ransackable_attributes = %w[reference source_location_id destination_location_id closed_at created_at number]
+    belongs_to :source_location, class_name: 'StockLocation'
+    belongs_to :destination_location, class_name: 'StockLocation'
 
     def to_param
       number

data/app/models/spree/store.rb

@@ -5,7 +5,7 @@ module Spree
     validates :url, presence: true
     validates :mail_from_address, presence: true
 
-    before_save :ensure_default_exists_and_is_unique
+    before_create :ensure_default_exists_and_is_unique
     before_destroy :validate_not_default
 
     scope :by_url, lambda { |url| where("url like ?", "%#{url}%") }
@@ -23,7 +23,7 @@ module Spree
 
     def ensure_default_exists_and_is_unique
       if default
-        Store.where.not(id: id).update_all(default: false)
+        Store.update_all(default: false)
       elsif Store.where(default: true).count == 0
         self.default = true
       end

data/app/models/spree/tax_rate.rb

@@ -12,27 +12,31 @@ module Spree
   class TaxRate < Spree::Base
     acts_as_paranoid
 
-    # Need to deal with adjustments before calculator is destroyed.
-    before_destroy :deals_with_adjustments_for_deleted_source
-
     include Spree::CalculatedAdjustments
     include Spree::AdjustmentSource
 
     belongs_to :zone, class_name: "Spree::Zone", inverse_of: :tax_rates
     belongs_to :tax_category, class_name: "Spree::TaxCategory", inverse_of: :tax_rates
 
-    has_many :adjustments, as: :source
-
     validates :amount, presence: true, numericality: true
     validates :tax_category_id, presence: true
     validates_with DefaultTaxZoneValidator
 
     scope :by_zone, ->(zone) { where(zone_id: zone) }
 
+    def self.potential_rates_for_zone(zone)
+      select("spree_tax_rates.*, spree_zones.default_tax").
+        joins(:zone).
+        merge(Spree::Zone.potential_matching_zones(zone)).
+        order("spree_zones.default_tax DESC")
+    end
+
     # Gets the array of TaxRates appropriate for the specified order
     def self.match(order_tax_zone)
       return [] unless order_tax_zone
-      rates = includes(zone: { zone_members: :zoneable }).load.select do |rate|
+
+      potential_rates = potential_rates_for_zone(order_tax_zone)
+      rates = potential_rates.includes(zone: { zone_members: :zoneable }).load.select do |rate|
         # Why "potentially"?
         # Go see the documentation for that method.
         rate.potentially_applicable?(order_tax_zone)
@@ -75,20 +79,16 @@ module Spree
     end
 
     # This method is best described by the documentation on #potentially_applicable?
-    def self.adjust(order_tax_zone, items)
-      rates = self.match(order_tax_zone)
+    def self.adjust(order, items)
+      rates = match(order.tax_zone)
       tax_categories = rates.map(&:tax_category)
       relevant_items, non_relevant_items = items.partition { |item| tax_categories.include?(item.tax_category) }
-
-      if relevant_items.present?
-        Spree::Adjustment.where(adjustable: relevant_items).tax.destroy_all # using destroy_all to ensure adjustment destroy callback fires.
-      end
-
+      Spree::Adjustment.where(adjustable: relevant_items).tax.destroy_all # using destroy_all to ensure adjustment destroy callback fires.
       relevant_items.each do |item|
         relevant_rates = rates.select { |rate| rate.tax_category == item.tax_category }
         store_pre_tax_amount(item, relevant_rates)
         relevant_rates.each do |rate|
-          rate.adjust(order_tax_zone, item)
+          rate.adjust(order, item)
         end
       end
       non_relevant_items.each do |item|
@@ -148,54 +148,29 @@ module Spree
       (self.included_in_price? && self.zone.default_tax)
     end
 
-    # Creates necessary tax adjustments for the order.
-    def adjust(order_tax_zone, item)
-      amount = compute_amount(item)
-      return if amount == 0
-
-      included = included_in_price && default_zone_or_zone_match?(order_tax_zone)
-
-      if amount < 0
-        label = Spree.t(:refund) + ' ' + create_label
-      end
-
-      self.adjustments.create!({
-        :adjustable => item,
-        :amount => amount,
-        :order_id => item.order_id,
-        :label => label || create_label,
-        :included => included
-      })
+    def adjust(order, item)
+      included = included_in_price && default_zone_or_zone_match?(order)
+      create_adjustment(order, item, included)
     end
 
-    # This method is used by Adjustment#update to recalculate the cost.
     def compute_amount(item)
-      if included_in_price
-        if default_zone_or_zone_match?(item.order.tax_zone)
-          calculator.compute(item)
-        else
-          # In this case, it's a refund.
-          calculator.compute(item) * - 1
-        end
-      else
-        calculator.compute(item)
-      end
-    end
-
-    def default_zone_or_zone_match?(order_tax_zone)
-      default_tax = Zone.default_tax
-      (default_tax && default_tax.contains?(order_tax_zone)) || order_tax_zone == self.zone
+      refund = included_in_price && !default_zone_or_zone_match?(item.order)
+      compute(item) * (refund ? -1 : 1)
     end
 
     private
 
-      def create_label
-        label = ""
-        label << (name.present? ? name : tax_category.name) + " "
-        label << (show_rate_in_label? ? "#{amount * 100}%" : "")
-        label << " (#{Spree.t(:included_in_price)})" if included_in_price?
-        label
-      end
+    def default_zone_or_zone_match?(order)
+      Zone.default_tax.try(:contains?, order.tax_zone) || order.tax_zone == zone
+    end
 
+    def label(adjustment_amount)
+      label = ""
+      label << Spree.t(:refund) << ' ' if adjustment_amount < 0
+      label << (name.present? ? name : tax_category.name) + " "
+      label << (show_rate_in_label? ? "#{amount * 100}%" : "")
+      label << " (#{Spree.t(:included_in_price)})" if included_in_price?
+      label
+    end
   end
 end

data/app/models/spree/taxon.rb

@@ -1,5 +1,12 @@
+# TODO let friendly id take care of sanitizing the url
+require 'stringex'
+
 module Spree
   class Taxon < Spree::Base
+    extend FriendlyId
+    friendly_id :permalink, slug_column: :permalink, use: :slugged
+    before_create :set_permalink
+
     acts_as_nested_set dependent: :destroy
 
     belongs_to :taxonomy, class_name: 'Spree::Taxonomy', inverse_of: :taxons
@@ -8,8 +15,6 @@ module Spree
 
     has_and_belongs_to_many :prototypes, join_table: :spree_taxons_prototypes
 
-    before_create :set_permalink
-
     validates :name, presence: true
     validates :meta_keywords, length: { maximum: 255 }
     validates :meta_description, length: { maximum: 255 }
@@ -49,7 +54,7 @@ module Spree
       end
     end
 
-    # Creates permalink based on Stringex's .to_url method
+    # Creates permalink base for friendly_id
     def set_permalink
       if parent.present?
         self.permalink = [parent.permalink, (permalink.blank? ? name.to_url : permalink.split('/').last)].join('/')
@@ -58,11 +63,6 @@ module Spree
       end
     end
 
-    # For #2759
-    def to_param
-      permalink
-    end
-
     def active_products
       products.active
     end

data/app/models/spree/taxonomy.rb

@@ -1,27 +1,22 @@
 module Spree
   class Taxonomy < Spree::Base
-    acts_as_list
-
     validates :name, presence: true
 
     has_many :taxons, inverse_of: :taxonomy
     has_one :root, -> { where parent_id: nil }, class_name: "Spree::Taxon", dependent: :destroy
 
-    after_save :set_name
+    after_create :set_root
+    after_save :set_root_taxon_name
 
-    default_scope -> { order("#{self.table_name}.position") }
+    default_scope { order("#{self.table_name}.position, #{self.table_name}.created_at") }
 
     private
-      def set_name
-        if root
-          root.update_columns(
-            name: name,
-            updated_at: Time.now,
-          )
-        else
-          self.root = Taxon.create!(taxonomy_id: id, name: name)
-        end
+      def set_root
+        self.root ||= Taxon.create!(taxonomy_id: id, name: name)
       end
 
+      def set_root_taxon_name
+        root.update_attributes(name: name)
+      end
   end
 end

data/app/models/spree/tracker.rb

@@ -1,7 +1,7 @@
 module Spree
   class Tracker < Spree::Base
     def self.current
-      tracker = where(active: true, environment: Rails.env).first
+      tracker = where(active: true).first
       tracker.analytics_id.present? ? tracker : nil if tracker
     end
   end

data/app/models/spree/variant.rb

@@ -1,7 +1,6 @@
 module Spree
   class Variant < Spree::Base
     acts_as_paranoid
-    acts_as_list scope: :product
 
     include Spree::DefaultPrice
 
@@ -37,23 +36,17 @@ module Spree
     validates_uniqueness_of :sku, allow_blank: true, conditions: -> { where(deleted_at: nil) }
 
     after_create :create_stock_items
+    after_create :set_position
     after_create :set_master_out_of_stock, unless: :is_master?
 
     after_touch :clear_in_stock_cache
 
     scope :in_stock, -> { joins(:stock_items).where('count_on_hand > ? OR track_inventory = ?', 0, false) }
 
-    self.whitelisted_ransackable_associations = %w[option_values product prices default_price]
-    self.whitelisted_ransackable_attributes = %w[weight sku]
-
     def self.active(currency = nil)
       joins(:prices).where(deleted_at: nil).where('spree_prices.currency' => currency || Spree::Config[:currency]).where('spree_prices.amount IS NOT NULL')
     end
 
-    def self.having_orders
-      joins(:line_items).distinct
-    end
-
     def tax_category
       if self[:tax_category_id].nil?
         product.tax_category
@@ -96,10 +89,6 @@ module Spree
       is_master? ? name : options_text
     end
 
-    def descriptive_name
-      is_master? ? name + ' - Master' : name + ' - ' + options_text
-    end
-
     # use deleted? rather than checking the attribute directly. this
     # allows extensions to override deleted? if they want to provide
     # their own definition.
@@ -179,7 +168,7 @@ module Spree
       return 0 unless options.present?
 
       options.keys.map { |key|
-        m = "#{key}_price_modifier_amount".to_sym
+        m = "#{options[key]}_price_modifier_amount".to_sym
         if self.respond_to? m
           self.send(m, options[key])
         else
@@ -247,6 +236,10 @@ module Spree
         end
       end
 
+      def set_position
+        self.update_column(:position, product.variants.maximum(:position).to_i + 1)
+      end
+
       def in_stock_cache_key
         "variant-#{id}-in_stock"
       end
@@ -256,5 +249,3 @@ module Spree
       end
   end
 end
-
-require_dependency 'spree/variant/scopes'

data/app/models/spree/zone.rb

@@ -2,21 +2,48 @@ module Spree
   class Zone < Spree::Base
     has_many :zone_members, dependent: :destroy, class_name: "Spree::ZoneMember", inverse_of: :zone
     has_many :tax_rates, dependent: :destroy, inverse_of: :zone
+    has_many :countries, through: :zone_members, source: :zoneable,
+      source_type: "Spree::Country"
+    has_many :states, through: :zone_members, source: :zoneable,
+      source_type: "Spree::State"
+
     has_and_belongs_to_many :shipping_methods, :join_table => 'spree_shipping_methods_zones'
 
     validates :name, presence: true, uniqueness: { allow_blank: true }
+
     after_save :remove_defunct_members
     after_save :remove_previous_default
 
     alias :members :zone_members
     accepts_nested_attributes_for :zone_members, allow_destroy: true, reject_if: proc { |a| a['zoneable_id'].blank? }
 
-    self.whitelisted_ransackable_attributes = ['description']
-
     def self.default_tax
       where(default_tax: true).first
     end
 
+    def self.potential_matching_zones(zone)
+      if zone.country?
+        # Match zones of the same kind with simialr countries
+        joins(countries: :zones).
+          where('zone_members_spree_countries_join.zone_id = ? OR ' +
+                'spree_zones.default_tax = ?', zone.id, true).
+          uniq
+      else
+        # Match zones of the same kind with similar states in AND match zones
+        # that have the states countries in
+        joins(:zone_members).where(
+          "(spree_zone_members.zoneable_type = 'Spree::State' AND
+            spree_zone_members.zoneable_id IN (?))
+           OR (spree_zone_members.zoneable_type = 'Spree::Country' AND
+            spree_zone_members.zoneable_id IN (?))
+           OR default_tax = ?",
+          zone.state_ids,
+          zone.states.pluck(:country_id),
+          true
+        ).uniq
+      end
+    end
+
     # Returns the matching zone with the highest priority zone type (State, Country, Zone.)
     # Returns nil in the case of no matches.
     def self.match(address)
@@ -34,13 +61,21 @@ module Spree
     end
 
     def kind
-      if members.any? && !members.any? { |member| member.try(:zoneable_type).nil? }
-        members.last.zoneable_type.demodulize.underscore
+      if kind?
+        super
+      else
+        not_nil_scope = members.where.not(zoneable_type: nil)
+        zone_type = not_nil_scope.order('created_at ASC').pluck(:zoneable_type).last
+        zone_type.demodulize.underscore if zone_type
       end
     end
 
-    def kind=(value)
-      # do nothing - just here to satisfy the form
+    def country?
+      kind == 'country'
+    end
+
+    def state?
+      kind == 'state'
     end
 
     def include?(address)
@@ -108,15 +143,14 @@ 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?
+        return false if (target.countries.pluck(:id) - countries.pluck(:id)).present?
       else
-        return false if (target.zoneables.collect(&:country).collect(&:id) - zoneables.collect(&:id)).present?
+        return false if (target.states.pluck(:country_id) - countries.pluck(:id)).present?
       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