spree_core 2.0.13 → 2.1.0

data/app/models/spree/product_property.rb

@@ -1,14 +1,12 @@
 module Spree
   class ProductProperty < ActiveRecord::Base
-    belongs_to :product, class_name: 'Spree::Product'
+    belongs_to :product,  class_name: 'Spree::Product'
     belongs_to :property, class_name: 'Spree::Property'
 
     validates :property, presence: true
     validates :value, length: { maximum: 255 }
 
-    attr_accessible :property_name, :value, :position
-
-    default_scope order: "#{quoted_table_name}.position"
+    default_scope -> { order("#{self.table_name}.position") }
 
     # virtual attributes for use with AJAX completion stuff
     def property_name
@@ -17,7 +15,7 @@ module Spree
 
     def property_name=(name)
       unless name.blank?
-        unless property = Property.find_by_name(name)
+        unless property = Property.find_by(name: name)
           property = Property.create(name: name, presentation: name)
         end
         self.property = property

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

@@ -6,9 +6,9 @@ module Spree
       class CreateAdjustment < PromotionAction
         include Spree::Core::CalculatedAdjustments
 
-        has_many :adjustments, :as => :originator
+        has_many :adjustments, as: :originator
 
-        delegate :eligible?, :to => :promotion
+        delegate :eligible?, to: :promotion
 
         before_validation :ensure_action_has_calculator
         before_destroy :deals_with_adjustments
@@ -34,12 +34,13 @@ module Spree
         # is saved
         def create_adjustment(label, target, calculable, mandatory=false)
           amount = compute_amount(calculable)
-          params = { :amount => amount,
-                    :source => calculable,
-                    :originator => self,
-                    :label => label,
-                    :mandatory => mandatory }
-          target.adjustments.create(params, :without_protection => true)
+          target.adjustments.create(
+            amount: amount,
+            source: calculable,
+            originator: self,
+            label: label,
+            mandatory: mandatory
+          )
         end
 
         # Ensure a negative amount which does not exceed the sum of the order's

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

@@ -2,9 +2,8 @@ module Spree
   class Promotion
     module Actions
       class CreateLineItems < PromotionAction
-        has_many :promotion_action_line_items, :foreign_key => :promotion_action_id
+        has_many :promotion_action_line_items, foreign_key: :promotion_action_id
         accepts_nested_attributes_for :promotion_action_line_items
-        attr_accessible :promotion_action_line_items_attributes
 
         delegate :eligible?, :to => :promotion
 

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

@@ -21,7 +21,7 @@ module Spree
           end
 
           def orders_by_email
-            Spree::Order.where(:email => email).complete
+            Spree::Order.where(email: email).complete
           end
       end
     end

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

@@ -4,10 +4,8 @@ module Spree
   class Promotion
     module Rules
       class ItemTotal < PromotionRule
-        preference :amount, :decimal, :default => 100.00
-        preference :operator, :string, :default => '>'
-
-        attr_accessible :preferred_amount, :preferred_operator
+        preference :amount, :decimal, default: 100.00
+        preference :operator, :string, default: '>'
 
         OPERATORS = ['gt', 'gte']
 

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

@@ -5,11 +5,11 @@ module Spree
   class Promotion
     module Rules
       class Product < PromotionRule
-        has_and_belongs_to_many :products, :class_name => '::Spree::Product', :join_table => 'spree_products_promotion_rules', :foreign_key => 'promotion_rule_id'
+        has_and_belongs_to_many :products, class_name: '::Spree::Product', join_table: 'spree_products_promotion_rules', foreign_key: 'promotion_rule_id'
         validate :only_one_promotion_per_product
 
         MATCH_POLICIES = %w(any all)
-        preference :match_policy, :string, :default => MATCH_POLICIES.first
+        preference :match_policy, :string, default: MATCH_POLICIES.first
 
         # scope/association that is used to test eligibility
         def eligible_products

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

@@ -2,14 +2,12 @@ module Spree
   class Promotion
     module Rules
       class User < PromotionRule
-        attr_accessible :user_ids_string
-
         if Spree.user_class
           belongs_to :user, class_name: Spree.user_class.to_s
           has_and_belongs_to_many :users, class_name: Spree.user_class.to_s, join_table: 'spree_promotion_rules_users', foreign_key: 'promotion_rule_id'
         else
           belongs_to :user
-          has_and_belongs_to_many :users, join_table: 'spree_promotion_rules_users', foreign_key: 'promotion_rule_id', :class_name => Spree.user_class
+          has_and_belongs_to_many :users, join_table: 'spree_promotion_rules_users', foreign_key: 'promotion_rule_id'
         end
 
         def eligible?(order, options = {})

data/app/models/spree/promotion.rb

@@ -14,11 +14,6 @@ module Spree
 
     accepts_nested_attributes_for :promotion_actions, :promotion_rules
 
-    attr_accessible :name, :event_name, :code, :match_policy,
-                    :path, :advertise, :description, :usage_limit,
-                    :starts_at, :expires_at, :promotion_rules_attributes,
-                    :promotion_actions_attributes
-
     validates_associated :rules
 
     validates :name, presence: true
@@ -26,6 +21,13 @@ module Spree
     validates :path, presence: true, if: lambda{|r| r.event_name == 'spree.content.visited' }
     validates :usage_limit, numericality: { greater_than: 0, allow_nil: true }
 
+    # TODO: This shouldn't be necessary with :autosave option but nested attribute updating of actions is broken without it
+    after_save :save_rules_and_actions
+
+    def save_rules_and_actions
+      (rules + actions).each &:save
+    end
+
     def self.advertised
       where(advertise: true)
     end
@@ -35,24 +37,21 @@ module Spree
     end
 
     def activate(payload)
-      if order_activatable?(payload[:order]) && eligible?(payload[:order])
-        # make sure code is always downcased (old databases might have mixed case codes)
-        if code.present?
-          event_code = payload[:coupon_code]
-          return unless event_code == self.code.downcase.strip
-        end
-
-        if path.present?
-          return unless path == payload[:path]
-        end
-
-        actions.each do |action|
-          action.perform(payload)
-        end
-
-        return true
+      return unless order_activatable? payload[:order]
+
+      # make sure code is always downcased (old databases might have mixed case codes)
+      if code.present?
+        event_code = payload[:coupon_code]
+        return unless event_code == self.code.downcase.strip
+      end
+
+      if path.present?
+        return unless path == payload[:path]
+      end
+
+      actions.each do |action|
+        action.perform(payload)
       end
-      false
     end
 
     # called anytime order.update! happens
@@ -77,7 +76,7 @@ module Spree
 
     # Products assigned to all product rules
     def products
-      @products ||= self.rules.all.inject([]) do |products, rule|
+      @products ||= self.rules.to_a.inject([]) do |products, rule|
         rule.respond_to?(:products) ? products << rule.products : products
       end.flatten.uniq
     end
@@ -92,7 +91,7 @@ module Spree
     end
 
     def credits
-      Adjustment.eligible.promotion.where(originator_id: actions.map(&:id))
+      Adjustment.promotion.where(originator_id: actions.map(&:id))
     end
 
     def credits_count

data/app/models/spree/promotion_action.rb

@@ -6,8 +6,6 @@ module Spree
 
     scope :of_type, ->(t) { where(type: t) }
 
-    attr_accessible :line_items_string
-
     # This method should be overriden in subclass
     # Updates the state of the order or performs some other action depending on the subclass
     # options will contain the payload from the event that activated the promotion. This will include

data/app/models/spree/promotion_action_line_item.rb

@@ -1,8 +1,6 @@
 module Spree
   class PromotionActionLineItem < ActiveRecord::Base
     belongs_to :promotion_action, class_name: 'Spree::Promotion::Actions::CreateLineItems'
-    belongs_to :variant, class_name: "Spree::Variant"
-
-    attr_accessible :quantity, :variant_id
+    belongs_to :variant, class_name: 'Spree::Variant'
   end
 end

data/app/models/spree/promotion_rule.rb

@@ -8,8 +8,6 @@ module Spree
     validate :promotion, presence: true
     validate :unique_per_activator, on: :create
 
-    attr_accessible :preferred_operator, :preferred_amount, :product, :product_ids_string, :preferred_match_policy
-
     def eligible?(order, options = {})
       raise 'eligible? should be implemented in a sub-class of Promotion::PromotionRule'
     end

data/app/models/spree/property.rb

@@ -5,16 +5,14 @@ module Spree
     has_many :product_properties, dependent: :delete_all
     has_many :products, through: :product_properties
 
-    attr_accessible :name, :presentation
-
     validates :name, :presentation, presence: true
 
-    scope :sorted, -> { order("#{quoted_table_name}.name") }
+    scope :sorted, -> { order(:name) }
 
     def self.find_all_by_prototype(prototype)
       id = prototype
       id = prototype.id if prototype.class == Prototype
-      joins("LEFT JOIN properties_prototypes ON property_id = #{quoted_table_name}.id").
+      joins("LEFT JOIN properties_prototypes ON property_id = #{self.table_name}.id").
         where(prototype_id: id)
     end
   end

data/app/models/spree/prototype.rb

@@ -3,8 +3,6 @@ module Spree
     has_and_belongs_to_many :properties, join_table: :spree_properties_prototypes
     has_and_belongs_to_many :option_types, join_table: :spree_option_types_prototypes
 
-    attr_accessible :name, :property_ids, :option_type_ids
-
     validates :name, presence: true
   end
 end

data/app/models/spree/return_authorization.rb

@@ -11,16 +11,14 @@ module Spree
     validates :amount, numericality: true
     validate :must_have_shipped_units
 
-    attr_accessible :amount, :reason, :stock_location_id
-
-    state_machine initial: 'authorized' do
-      after_transition to: 'received', do: :process_return
+    state_machine initial: :authorized do
+      after_transition to: :received, do: :process_return
 
       event :receive do
-        transition to: 'received', from: 'authorized', if: :allow_receive?
+        transition to: :received, from: :authorized, if: :allow_receive?
       end
       event :cancel do
-        transition to: 'canceled', from: 'authorized'
+        transition to: :canceled, from: :authorized
       end
     end
 
@@ -61,7 +59,7 @@ module Spree
     end
 
     def returnable_inventory
-      order.shipped_shipments.collect{|s| s.inventory_units.all}.flatten
+      order.shipped_shipments.collect{|s| s.inventory_units.to_a}.flatten
     end
 
     private
@@ -83,8 +81,7 @@ module Spree
       def process_return
         inventory_units.each do |iu|
           iu.return!
-          stock_item = Spree::StockItem.where(variant_id: iu.variant.id, stock_location_id: stock_location_id).first
-          Spree::StockMovement.create!(stock_item_id: stock_item.id, quantity: 1)
+          Spree::StockMovement.create!(stock_item_id: iu.find_stock_item.id, quantity: 1)
         end
 
         credit = Adjustment.new(amount: amount.abs * -1, label: Spree.t(:rma_credit))

data/app/models/spree/role.rb

@@ -1,7 +1,5 @@
 module Spree
   class Role < ActiveRecord::Base
-    attr_accessible :name
-
     has_and_belongs_to_many :users, join_table: 'spree_roles_users', class_name: Spree.user_class.to_s
   end
 end

data/app/models/spree/shipment.rb

@@ -2,7 +2,7 @@ require 'ostruct'
 
 module Spree
   class Shipment < ActiveRecord::Base
-    belongs_to :order, class_name: 'Spree::Order', touch: true
+    belongs_to :order, class_name: 'Spree::Order'
     belongs_to :address, class_name: 'Spree::Address'
     belongs_to :stock_location, class_name: 'Spree::StockLocation'
 
@@ -12,16 +12,15 @@ module Spree
     has_many :inventory_units, dependent: :delete_all
     has_one :adjustment, as: :source, dependent: :destroy
 
+    before_create :generate_shipment_number
     after_save :ensure_correct_adjustment, :update_order
 
     attr_accessor :special_instructions
-    attr_accessible :order, :special_instructions, :stock_location_id, :number,
-                    :tracking, :address, :inventory_units, :selected_shipping_rate_id
 
     accepts_nested_attributes_for :address
     accepts_nested_attributes_for :inventory_units
 
-    make_permalink field: :number, length: 11, prefix: 'H'
+    make_permalink field: :number
 
     scope :shipped, -> { with_state('shipped') }
     scope :ready,   -> { with_state('ready') }
@@ -65,7 +64,9 @@ module Spree
     end
 
     def to_param
-      number
+      number if number
+      generate_shipment_number unless number
+      number.to_s.to_url.upcase
     end
 
     def backordered?
@@ -101,16 +102,12 @@ module Spree
 
     def refresh_rates
       return shipping_rates if shipped?
-      return [] unless can_get_rates?
-
-      # StockEstimator.new assigment below will replace the current shipping_method
-      original_shipping_method_id = shipping_method.try(:id)
 
       self.shipping_rates = Stock::Estimator.new(order).shipping_rates(to_package)
 
       if shipping_method
         selected_rate = shipping_rates.detect { |rate|
-          rate.shipping_method_id == original_shipping_method_id
+          rate.shipping_method_id == shipping_method.id
         }
         self.selected_shipping_rate_id = selected_rate.id if selected_rate
       end
@@ -165,8 +162,8 @@ module Spree
     end
 
     def line_items
-      if order.complete? and Spree::Config.track_inventory_levels
-        order.line_items.select { |li| !li.should_track_inventory? || inventory_units.pluck(:variant_id).include?(li.variant_id) }
+      if order.complete? and Spree::Config[:track_inventory_levels]
+        order.line_items.select { |li| inventory_units.pluck(:variant_id).include?(li.variant_id) }
       else
         order.line_items
       end
@@ -229,10 +226,7 @@ module Spree
     end
 
     def set_up_inventory(state, variant, order)
-      self.inventory_units.create(
-        { variant_id: variant.id, state: state, order_id: order.id },
-        without_protection: true
-      )
+      self.inventory_units.create(variant_id: variant.id, state: state, order_id: order.id)
     end
 
     private
@@ -242,13 +236,17 @@ module Spree
       end
 
       def manifest_restock(item)
-        if item.states["on_hand"].to_i > 0
-         stock_location.restock item.variant, item.states["on_hand"], self
-        end
+        stock_location.restock item.variant, item.quantity, self
+      end
 
-        if item.states["backordered"].to_i > 0
-          stock_location.restock_backordered item.variant, item.states["backordered"]
+      def generate_shipment_number
+        return number unless number.blank?
+        record = true
+        while record
+          random = "H#{Array.new(11) { rand(9) }.join}"
+          record = self.class.where(number: random).first
         end
+        self.number = random
       end
 
       def description_for_shipping_charge
@@ -288,9 +286,5 @@ module Spree
       def update_order
         order.update!
       end
-
-      def can_get_rates?
-        order.ship_address && order.ship_address.valid?
-      end
   end
 end

data/app/models/spree/shipping_calculator.rb

@@ -1,7 +1,5 @@
 module Spree
   class ShippingCalculator < Calculator
-    belongs_to :calculable, polymorphic: true
-
     def compute(package_or_shipment)
       package = package_or_shipment.respond_to?(:to_package) ?
                   package_or_shipment.to_package : package_or_shipment

data/app/models/spree/shipping_category.rb

@@ -4,7 +4,5 @@ module Spree
     has_many :products
     has_many :shipping_method_categories
     has_many :shipping_methods, through: :shipping_method_categories
-
-    attr_accessible :name
   end
 end

data/app/models/spree/shipping_method.rb

@@ -3,20 +3,17 @@ module Spree
     include Spree::Core::CalculatedAdjustments
     DISPLAY = [:both, :front_end, :back_end]
 
-    default_scope where(deleted_at: nil)
+    default_scope -> { where(deleted_at: nil) }
 
+    has_many :shipments
     has_many :shipping_method_categories
     has_many :shipping_categories, through: :shipping_method_categories
     has_many :shipping_rates
-    has_many :shipments, :through => :shipping_rates
 
     has_and_belongs_to_many :zones, :join_table => 'spree_shipping_methods_zones',
                                     :class_name => 'Spree::Zone',
                                     :foreign_key => 'shipping_method_id'
 
-    attr_accessible :name, :admin_name, :zones, :display_on, :shipping_category_id,
-                    :match_none, :match_one, :match_all, :tracking_url
-
     validates :name, presence: true
 
     validate :at_least_one_shipping_category
@@ -25,16 +22,6 @@ module Spree
       Spree.t(:shipping)
     end
 
-    def zone
-      ActiveSupport::Deprecation.warn("[SPREE] ShippingMethod#zone is no longer correct. Multiple zones need to be supported")
-      zones.first
-    end
-
-    def zone=(zone)
-      ActiveSupport::Deprecation.warn("[SPREE] ShippingMethod#zone= is no longer correct. Multiple zones need to be supported")
-      zones = zone
-    end
-
     def include?(address)
       return false unless address
       zones.any? do |zone|
@@ -43,12 +30,11 @@ module Spree
     end
 
     def build_tracking_url(tracking)
-      return if tracking.blank? || tracking_url.blank?
-      tracking_url.gsub(/:tracking/, ERB::Util.url_encode(tracking)) # :url_encode exists in 1.8.7 through 2.1.0
+      tracking_url.gsub(/:tracking/, tracking) unless tracking.blank? || tracking_url.blank?
     end
 
     def self.calculators
-      spree_calculators.send(model_name_without_spree_namespace).select{|c| c.name.start_with?("Spree::Calculator::Shipping::")}
+      spree_calculators.send(model_name_without_spree_namespace).select{ |c| c < Spree::ShippingCalculator }
     end
 
     # Some shipping methods are only meant to be set via backend
@@ -64,11 +50,11 @@ module Spree
       end
 
       def self.on_backend_query
-        "#{quoted_table_name}.display_on != 'front_end' OR #{quoted_table_name}.display_on IS NULL"
+        "#{table_name}.display_on != 'front_end' OR #{table_name}.display_on IS NULL"
       end
 
       def self.on_frontend_query
-        "#{quoted_table_name}.display_on != 'back_end' OR #{quoted_table_name}.display_on IS NULL"
+        "#{table_name}.display_on != 'back_end' OR #{table_name}.display_on IS NULL"
       end
   end
 end

data/app/models/spree/shipping_rate.rb

@@ -3,12 +3,17 @@ module Spree
     belongs_to :shipment, class_name: 'Spree::Shipment'
     belongs_to :shipping_method, class_name: 'Spree::ShippingMethod'
 
-    attr_accessible :id, :shipping_method, :shipment,
-                    :name, :cost, :selected, :shipping_method_id
-
-    scope :frontend, -> { includes(:shipping_method).where(ShippingMethod.on_frontend_query) }
-    scope :backend, -> { includes(:shipping_method).where(ShippingMethod.on_backend_query) }
-
+    scope :frontend,
+      -> { includes(:shipping_method).
+          where(ShippingMethod.on_frontend_query).
+          references(:shipping_method).
+          order("cost ASC") }
+    scope :backend,
+      -> { includes(:shipping_method).
+           where(ShippingMethod.on_backend_query).
+           references(:shipping_method).
+           order("cost ASC") }
+    
     delegate :order, :currency, to: :shipment
     delegate :name, to: :shipping_method
 
@@ -21,10 +26,7 @@ module Spree
 
       Spree::Money.new(price, { currency: currency })
     end
-    alias_method :display_cost, :display_price
 
-    def shipping_method
-      Spree::ShippingMethod.unscoped { super }
-    end
+    alias_method :display_cost, :display_price
   end
 end

data/app/models/spree/state.rb

@@ -4,17 +4,15 @@ module Spree
 
     validates :country, :name, presence: true
 
-    attr_accessible :name, :abbr
-
     def self.find_all_by_name_or_abbr(name_or_abbr)
-      where("#{quoted_table_name}.name = ? OR #{quoted_table_name}.abbr = ?", name_or_abbr, name_or_abbr)
+      where('name = ? OR abbr = ?', name_or_abbr, name_or_abbr)
     end
 
     # table of { country.id => [ state.id , state.name ] }, arrays sorted by name
     # blank is added elsewhere, if needed
     def self.states_group_by_country_id
       state_info = Hash.new { |h, k| h[k] = [] }
-      self.order("#{quoted_table_name}.name ASC").each { |state|
+      self.order('name ASC').each { |state|
         state_info[state.country_id.to_s].push [state.id, state.name]
       }
       state_info

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

@@ -10,14 +10,14 @@ module Spree
           quantity = line_item.quantity
         end
 
-        quantifier = Stock::Quantifier.new(line_item.variant)
+        quantifier = Stock::Quantifier.new(line_item.variant_id)
 
         unless quantifier.can_supply? quantity
           variant = line_item.variant
           display_name = %Q{#{variant.name}}
           display_name += %Q{ (#{variant.options_text})} unless variant.options_text.blank?
 
-          line_item.errors[:quantity] << Spree.t(:selected_quantity_not_available, :scope => :order_populator, :item => display_name.inspect)
+          line_item.errors[:quantity] << Spree.t(:out_of_stock, :scope => :order_populator, :item => display_name.inspect)
         end
       end
     end

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

@@ -15,8 +15,7 @@ module Spree
 
         shipping_methods.each do |shipping_method|
           cost = calculate_cost(shipping_method, package)
-          rate = shipping_method.shipping_rates.new(:cost => cost) unless cost.nil?
-          shipping_rates << rate unless rate.nil?
+          shipping_rates << shipping_method.shipping_rates.new(:cost => cost) unless cost.nil?
         end
 
         shipping_rates.sort_by! { |r| r.cost || 0 }
@@ -35,30 +34,17 @@ module Spree
       end
 
       private
-
       def shipping_methods(package)
-        package.shipping_methods.select do |ship_method|
-          calculator = ship_method.calculator
-          begin
-            calculator.available?(package) &&
-            ship_method.include?(order.ship_address) &&
-            (calculator.preferences[:currency].nil? ||
-             calculator.preferences[:currency] == currency)
-          rescue Exception => exception
-            log_calculator_exception(ship_method, exception)
-          end
-        end
+        shipping_methods = package.shipping_methods
+        shipping_methods.delete_if { |ship_method| !ship_method.calculator.available?(package) }
+        shipping_methods.delete_if { |ship_method| !ship_method.include?(order.ship_address) }
+        shipping_methods.delete_if { |ship_method| !(ship_method.calculator.preferences[:currency].nil? || ship_method.calculator.preferences[:currency] == currency) }
+        shipping_methods
       end
 
       def calculate_cost(shipping_method, package)
         shipping_method.calculator.compute(package)
       end
-
-      def log_calculator_exception(ship_method, exception)
-        Rails.logger.error("Something went wrong calculating rates with the #{ship_method.name} (ID=#{ship_method.id}) shipping method.")
-        Rails.logger.error("*" * 50)
-        Rails.logger.error(exception.backtrace.join("\n"))
-      end
     end
   end
 end

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

@@ -20,7 +20,7 @@ module Spree
       def default_package
         package = Package.new(stock_location, order)
         order.line_items.each do |line_item|
-          if line_item.should_track_inventory?
+          if Config.track_inventory_levels
             next unless stock_location.stock_item(line_item.variant)
 
             on_hand, backordered = stock_location.fill_status(line_item.variant, line_item.quantity)