spree_core 1.3.5 → 2.0.0.rc1

data/app/models/spree/calculator/shipping/price_sack.rb

@@ -0,0 +1,32 @@
+require_dependency 'spree/shipping_calculator'
+# For #to_d method on Ruby 1.8
+require 'bigdecimal/util'
+
+module Spree
+  module Calculator::Shipping
+    class PriceSack < ShippingCalculator
+      preference :minimal_amount, :decimal, :default => 0
+      preference :normal_amount, :decimal, :default => 0
+      preference :discount_amount, :decimal, :default => 0
+      preference :currency, :string, :default => Spree::Config[:currency]
+
+      attr_accessible :preferred_minimal_amount,
+                      :preferred_normal_amount,
+                      :preferred_discount_amount,
+                      :preferred_currency
+
+      def self.description
+        Spree.t(:shipping_price_sack)
+      end
+
+      def compute_package(package)
+        content_items = package.contents
+        if total(content_items) < self.preferred_minimal_amount
+          self.preferred_normal_amount
+        else
+          self.preferred_discount_amount
+        end
+      end
+    end
+  end
+end

data/app/models/spree/calculator.rb

@@ -1,12 +1,12 @@
 module Spree
   class Calculator < ActiveRecord::Base
-    belongs_to :calculable, :polymorphic => true
+    belongs_to :calculable, polymorphic: true
 
     # This method must be overriden in concrete calculator.
     #
     # It should return amount computed based on #calculable and/or optional parameter
-    def compute(something=nil)
-      raise(NotImplementedError, 'please use concrete calculator')
+    def compute(something = nil)
+      raise NotImplementedError, 'please use concrete calculator'
     end
 
     # overwrite to provide description for your calculators

data/app/models/spree/classification.rb

@@ -1,10 +1,7 @@
 module Spree
   class Classification < ActiveRecord::Base
     self.table_name = 'spree_products_taxons'
-    belongs_to :product, :class_name => "Spree::Product"
-    belongs_to :taxon, :class_name => "Spree::Taxon"
-
-    # For #3494
-    validates_uniqueness_of :taxon_id, :scope => :product_id, :message => :already_linked
+    belongs_to :product, class_name: "Spree::Product"
+    belongs_to :taxon, class_name: "Spree::Taxon"
   end
 end

data/app/models/spree/country.rb

@@ -1,17 +1,14 @@
 module Spree
   class Country < ActiveRecord::Base
-    has_many :states, :order => "name ASC"
+    has_many :states, order: 'name ASC'
 
-    validates :name, :iso_name, :presence => true
+    validates :name, :iso_name, presence: true
 
     attr_accessible :name, :iso_name, :states_required
 
-
     def self.states_required_by_country_id
       states_required = Hash.new(true)
-      self.all.each { |country|
-        states_required[country.id.to_s]= country.states_required
-      }
+      all.each { |country| states_required[country.id.to_s]= country.states_required }
       states_required
     end
 

data/app/models/spree/credit_card.rb

@@ -1,46 +1,35 @@
 module Spree
   class CreditCard < ActiveRecord::Base
-    has_many :payments, :as => :source
+    has_many :payments, as: :source
 
     before_save :set_last_digits
     after_validation :set_card_type
 
     attr_accessor :number, :verification_value
 
-    validates :month, :year, :numericality => { :only_integer => true }
-    validates :number, :presence => true, :unless => :has_payment_profile?, :on => :create
-    validates :verification_value, :presence => true, :unless => :has_payment_profile?, :on => :create
+    validates :month, :year, numericality: { only_integer: true }
+    validates :number, presence: true, unless: :has_payment_profile?, on: :create
+    validates :verification_value, presence: true, unless: :has_payment_profile?, on: :create
 
     attr_accessible :first_name, :last_name, :number, :verification_value, :year,
                     :month, :gateway_customer_profile_id, :gateway_payment_profile_id
 
+    scope :with_payment_profile, -> { where('gateway_customer_profile_id IS NOT NULL') }
+
     def set_last_digits
       number.to_s.gsub!(/\s/,'')
       verification_value.to_s.gsub!(/\s/,'')
       self.last_digits ||= number.to_s.length <= 4 ? number : number.to_s.slice(-4..-1)
     end
 
-    # cheap hack to get to the type? method from deep within ActiveMerchant without stomping on
-    # potentially existing methods in CreditCard
+    # cheap hack to get to the type? method from deep within ActiveMerchant
+    # without stomping on potentially existing methods in CreditCard
     class CardDetector
       class << self
         include ActiveMerchant::Billing::CreditCardMethods::ClassMethods
       end
     end
 
-    # Some payment gateways, such as USA EPay, only support an ActiveMerchant::Billing::CreditCard
-    # object, rather than an object *like* that. So we need to convert it.
-    def to_active_merchant
-      ActiveMerchant::Billing::CreditCard.new(
-        :number => number,
-        :month => month,
-        :year => year,
-        :verification_value => verification_value,
-        :first_name => first_name,
-        :last_name => last_name
-        )
-    end
-
     # sets self.cc_type while we still have the card number
     def set_card_type
       self.cc_type ||= CardDetector.brand?(number)
@@ -50,14 +39,6 @@ module Spree
       first_name? && last_name?
     end
 
-    def first_name?
-      first_name.present?
-    end
-
-    def last_name?
-      last_name.present?
-    end
-
     def name
       "#{first_name} #{last_name}"
     end
@@ -76,26 +57,24 @@ module Spree
       spree_cc_type
     end
 
-    scope :with_payment_profile, lambda { where('gateway_customer_profile_id IS NOT NULL') }
-
     def actions
       %w{capture void credit}
     end
 
     # Indicates whether its possible to capture the payment
     def can_capture?(payment)
-      payment.state == 'pending' || payment.state == 'checkout'
+      payment.pending? || payment.checkout?
     end
 
     # Indicates whether its possible to void the payment.
     def can_void?(payment)
-      payment.state != 'void'
+      !payment.void?
     end
 
     # Indicates whether its possible to credit the payment.  Note that most gateways require that the
     # payment be settled first which generally happens within 12-24 hours of the transaction.
     def can_credit?(payment)
-      return false unless payment.state == 'completed'
+      return false unless payment.completed?
       return false unless payment.order.payment_state == 'credit_owed'
       payment.credit_allowed > 0
     end

data/app/models/spree/gateway.rb

@@ -2,10 +2,10 @@ module Spree
   class Gateway < PaymentMethod
     delegate_belongs_to :provider, :authorize, :purchase, :capture, :void, :credit
 
-    validates :name, :type, :presence => true
+    validates :name, :type, presence: true
 
-    preference :server, :string, :default => 'test'
-    preference :test_mode, :boolean, :default => true
+    preference :server, :string, default: 'test'
+    preference :test_mode, :boolean, default: true
 
     attr_accessible :preferred_server, :preferred_test_mode
 

data/app/models/spree/image.rb

@@ -6,11 +6,12 @@ module Spree
     attr_accessible :alt, :attachment, :position, :viewable_type, :viewable_id
 
     has_attached_file :attachment,
-                      :styles => { :mini => '48x48>', :small => '100x100>', :product => '240x240>', :large => '600x600>' },
-                      :default_style => :product,
-                      :url => '/spree/products/:id/:style/:basename.:extension',
-                      :path => ':rails_root/public/spree/products/:id/:style/:basename.:extension',
-                      :convert_options => { :all => '-strip -auto-orient' }
+                      styles: { mini: '48x48>', small: '100x100>', product: '240x240>', large: '600x600>' },
+                      default_style: :product,
+                      url: '/spree/products/:id/:style/:basename.:extension',
+                      path: ':rails_root/public/spree/products/:id/:style/:basename.:extension',
+                      convert_options: { all: '-strip -auto-orient' }
+
     # save the w,h of the original image (from which others can be calculated)
     # we need to look at the write-queue for images which have not been saved yet
     after_post_process :find_dimensions
@@ -18,7 +19,7 @@ module Spree
     include Spree::Core::S3Support
     supports_s3 :attachment
 
-    Spree::Image.attachment_definitions[:attachment][:styles] = ActiveSupport::JSON.decode(Spree::Config[:attachment_styles])
+    Spree::Image.attachment_definitions[:attachment][:styles] = ActiveSupport::JSON.decode(Spree::Config[:attachment_styles]).symbolize_keys!
     Spree::Image.attachment_definitions[:attachment][:path] = Spree::Config[:attachment_path]
     Spree::Image.attachment_definitions[:attachment][:url] = Spree::Config[:attachment_url]
     Spree::Image.attachment_definitions[:attachment][:default_url] = Spree::Config[:attachment_default_url]

data/app/models/spree/inventory_unit.rb

@@ -1,126 +1,59 @@
 module Spree
   class InventoryUnit < ActiveRecord::Base
-    belongs_to :variant, :class_name => "Spree::Variant"
-    belongs_to :order, :class_name => "Spree::Order"
-    belongs_to :shipment, :class_name => "Spree::Shipment"
-    belongs_to :return_authorization, :class_name => "Spree::ReturnAuthorization"
+    belongs_to :variant, class_name: "Spree::Variant"
+    belongs_to :order, class_name: "Spree::Order"
+    belongs_to :shipment, class_name: "Spree::Shipment"
+    belongs_to :return_authorization, class_name: "Spree::ReturnAuthorization"
 
-    scope :backordered, lambda { where(:state => 'backordered') }
-    scope :shipped, lambda { where(:state => 'shipped') }
+    scope :backordered, -> { where state: 'backordered' }
+    scope :shipped,     -> { where state: 'shipped' }
 
-    def self.backorder
-      warn "[SPREE] Spree::InventoryUnit.backorder will be deprecated in Spree 1.3. Please use Spree::Product.backordered instead."
-      backordered
-    end
-
-    attr_accessible :shipment
+    attr_accessible :shipment, :variant_id
 
     # state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
-    state_machine :initial => 'on_hand' do
+    state_machine initial: :on_hand do
       event :fill_backorder do
-        transition :to => 'sold', :from => 'backordered'
+        transition to: :on_hand, from: :backordered
       end
+      after_transition on: :fill_backorder, do: :update_order
+
       event :ship do
-        transition :to => 'shipped', :if => :allow_ship?
-      end
-      event :return do
-        transition :to => 'returned', :from => 'shipped'
+        transition to: :shipped, if: :allow_ship?
       end
 
-      after_transition :on => :fill_backorder, :do => :update_order
-      after_transition :to => 'returned', :do => :restock_variant
-    end
-
-    # Assigns inventory to a newly completed order.
-    # Should only be called once during the life-cycle of an order, on transition to completed.
-    #
-    def self.assign_opening_inventory(order)
-      return [] unless order.completed?
-
-      #increase inventory to meet initial requirements
-      order.line_items.each do |line_item|
-        increase(order, line_item.variant, line_item.quantity)
+      event :return do
+        transition to: :returned, from: :shipped
       end
     end
 
-    # manages both variant.count_on_hand and inventory unit creation
-    #
-    def self.increase(order, variant, quantity)
-      back_order = determine_backorder(order, variant, quantity)
-      sold = quantity - back_order
-
-      #set on_hand if configured
-      if self.track_levels?(variant)
-        variant.decrement!(:count_on_hand, quantity)
-      end
-
-      #create units if configured
-      if Spree::Config[:create_inventory_units]
-        create_units(order, variant, sold, back_order)
-      end
+    def self.backordered_for_stock_item(stock_item)
+      stock_locations_table = Spree::StockLocation.table_name
+      shipments_table = Spree::Shipment.table_name
+      joins(shipment: :stock_location).
+      where("#{stock_locations_table}.id = ?", stock_item.stock_location_id).
+      where(variant_id: stock_item.variant_id).
+      where("#{shipments_table}.state != 'canceled'").
+      backordered.order('created_at ASC')
     end
 
-    def self.decrease(order, variant, quantity)
-      if self.track_levels?(variant)
-        variant.increment!(:count_on_hand, quantity)
-      end
-
-      if Spree::Config[:create_inventory_units]
-        destroy_units(order, variant, quantity)
-      end
+    def self.finalize_units!(inventory_units)
+      inventory_units.map { |iu| iu.update_column(:pending, false) }
     end
 
-    def self.track_levels?(variant)
-      Spree::Config[:track_inventory_levels] && !variant.on_demand
+    def find_stock_item
+      Spree::StockItem.where(stock_location_id: shipment.stock_location_id,
+        variant_id: variant_id).first
     end
 
     private
-      def allow_ship?
-        Spree::Config[:allow_backorder_shipping] || self.sold?
-      end
-
-      def self.determine_backorder(order, variant, quantity)
-        if variant.on_hand == 0
-          quantity
-        elsif variant.on_hand.present? and variant.on_hand < quantity
-          quantity - (variant.on_hand < 0 ? 0 : variant.on_hand)
-        else
-          0
-        end
-      end
-
-      def self.destroy_units(order, variant, quantity)
-        variant_units = order.inventory_units.group_by(&:variant_id)
-        return unless variant_units.include? variant.id
 
-        variant_units = variant_units[variant.id].reject do |variant_unit|
-          variant_unit.state == 'shipped'
-        end.sort_by(&:state)
-
-        quantity.times do
-          inventory_unit = variant_units.shift
-          inventory_unit.destroy
-        end
-      end
-
-      def self.create_units(order, variant, sold, back_order)
-        return if back_order > 0 && !Spree::Config[:allow_backorders]
-
-        shipment = order.shipments.detect { |shipment| !shipment.shipped? }
-
-        sold.times { order.inventory_units.create({:variant => variant, :state => 'sold', :shipment => shipment}, :without_protection => true) }
-        back_order.times { order.inventory_units.create({:variant => variant, :state => 'backordered', :shipment => shipment}, :without_protection => true) }
+      def allow_ship?
+        Spree::Config[:allow_backorder_shipping] || self.on_hand?
       end
 
       def update_order
         order.update!
       end
-
-      def restock_variant
-        if self.class.track_levels?(variant)
-          variant.on_hand += 1
-          variant.save
-        end
-      end
   end
 end
+

data/app/models/spree/legacy_user.rb

@@ -4,9 +4,9 @@ module Spree
     self.table_name = 'spree_users'
     attr_accessible :email, :password, :password_confirmation
 
-    has_many :orders, :foreign_key => :user_id
-    belongs_to :ship_address, :class_name => 'Spree::Address'
-    belongs_to :bill_address, :class_name => 'Spree::Address'
+    has_many :orders, foreign_key: :user_id
+    belongs_to :ship_address, class_name: 'Spree::Address'
+    belongs_to :bill_address, class_name: 'Spree::Address'
 
     scope :registered
 

data/app/models/spree/line_item.rb

@@ -1,28 +1,32 @@
 module Spree
   class LineItem < ActiveRecord::Base
     before_validation :adjust_quantity
-    belongs_to :order, :class_name => "Spree::Order"
-    belongs_to :variant, :class_name => "Spree::Variant"
+    belongs_to :order, class_name: "Spree::Order"
+    belongs_to :variant, class_name: "Spree::Variant"
 
-    has_one :product, :through => :variant
-    has_many :adjustments, :as => :adjustable, :dependent => :destroy
+    has_one :product, through: :variant
+    has_many :adjustments, as: :adjustable, dependent: :destroy
 
     before_validation :copy_price
 
-    validates :variant, :presence => true
-    validates :quantity, :numericality => { :only_integer => true, :message => I18n.t('validation.must_be_int'), :greater_than => -1 }
-    validates :price, :numericality => true
-    validate :stock_availability
-    validate :quantity_no_less_than_shipped
+    validates :variant, presence: true
+    validates :quantity, numericality: {
+      only_integer: true,
+      greater_than: -1,
+      message: Spree.t('validation.must_be_int')
+    }
+    validates :price, numericality: true
+    validates_with Stock::AvailabilityValidator
 
     attr_accessible :quantity, :variant_id
 
     before_save :update_inventory
-    before_destroy :ensure_not_shipped, :remove_inventory
 
     after_save :update_order
     after_destroy :update_order
 
+    attr_accessor :target_shipment
+
     def copy_price
       if variant
         self.price = variant.price if price.nil?
@@ -31,11 +35,13 @@ module Spree
     end
 
     def increment_quantity
-      self.quantity += 1
+      ActiveSupport::Deprecation.warn("[SPREE] Spree::LineItem#increment_quantity will be deprecated in Spree 2.1, please use quantity.increment! instead.")
+      self.quantity.increment!
     end
 
     def decrement_quantity
-      self.quantity -= 1
+      ActiveSupport::Deprecation.warn("[SPREE] Spree::LineItem#decrement_quantity will be deprecated in Spree 2.1, please use quantity.decrement! instead.")
+      self.quantity.decrement!
     end
 
     def amount
@@ -44,12 +50,12 @@ module Spree
     alias total amount
 
     def single_money
-      Spree::Money.new(price, { :currency => currency })
+      Spree::Money.new(price, { currency: currency })
     end
     alias single_display_amount single_money
 
     def money
-      Spree::Money.new(amount, { :currency => currency })
+      Spree::Money.new(amount, { currency: currency })
     end
     alias display_total money
     alias display_amount money
@@ -59,37 +65,20 @@ module Spree
     end
 
     def sufficient_stock?
-      return true if Spree::Config[:allow_backorders]
-      if new_record? || !order.completed?
-        variant.on_hand >= quantity
-      else
-        variant.on_hand >= (quantity - self.changed_attributes['quantity'].to_i)
-      end
+      Stock::Quantifier.new(variant_id).can_supply? quantity
     end
 
     def insufficient_stock?
       !sufficient_stock?
     end
 
+    def assign_stock_changes_to=(shipment)
+      @preferred_shipment = shipment
+    end
+
     private
       def update_inventory
-        return true unless order.completed?
-
-        if new_record?
-          InventoryUnit.increase(order, variant, quantity)
-        elsif old_quantity = self.changed_attributes['quantity']
-          if old_quantity < quantity
-            InventoryUnit.increase(order, variant, (quantity - old_quantity))
-          elsif old_quantity > quantity
-            InventoryUnit.decrease(order, variant, (old_quantity - quantity))
-          end
-        end
-      end
-
-      def remove_inventory
-        return true unless order.completed?
-
-        InventoryUnit.decrease(order, variant, quantity)
+        Spree::OrderInventory.new(self.order).verify(self, target_shipment)
       end
 
       def update_order
@@ -97,25 +86,6 @@ module Spree
         order.create_tax_charge!
         order.update!
       end
-
-      def ensure_not_shipped
-        if order.try(:inventory_units).to_a.any?{ |unit| unit.variant_id == variant_id && unit.shipped? }
-          errors.add :base, I18n.t('validation.cannot_destroy_line_item_as_inventory_units_have_shipped')
-          return false
-        end
-      end
-
-      # Validation
-      def stock_availability
-        return if sufficient_stock?
-        errors.add(:quantity, I18n.t('validation.exceeds_available_stock'))
-      end
-
-      def quantity_no_less_than_shipped
-        already_shipped = order.shipments.reduce(0) { |acc, s| acc + s.inventory_units.shipped.where(:variant_id => variant_id).count }
-        unless quantity >= already_shipped
-          errors.add(:quantity, I18n.t('validation.cannot_be_less_than_shipped_units'))
-        end
-      end
   end
 end
+

data/app/models/spree/log_entry.rb

@@ -1,6 +1,6 @@
 module Spree
   class LogEntry < ActiveRecord::Base
-    belongs_to :source, :polymorphic => true
+    belongs_to :source, polymorphic: true
 
     # Fix for #1767
     # If a payment fails, we want to make sure we keep the record of it failing

data/app/models/spree/option_type.rb

@@ -1,14 +1,14 @@
 module Spree
   class OptionType < ActiveRecord::Base
-    has_many :option_values, :order => :position, :dependent => :destroy
-    has_many :product_option_types, :dependent => :destroy
-    has_and_belongs_to_many :prototypes, :join_table => 'spree_option_types_prototypes'
+    has_many :option_values, order: :position, dependent: :destroy
+    has_many :product_option_types, dependent: :destroy
+    has_and_belongs_to_many :prototypes, join_table: 'spree_option_types_prototypes'
 
     attr_accessible :name, :presentation, :option_values_attributes
 
-    validates :name, :presentation, :presence => true
-    default_scope :order => "#{self.table_name}.position"
+    validates :name, :presentation, presence: true
+    default_scope order: "#{self.table_name}.position"
 
-    accepts_nested_attributes_for :option_values, :reject_if => lambda { |ov| ov[:name].blank? || ov[:presentation].blank? }, :allow_destroy => true
+    accepts_nested_attributes_for :option_values, reject_if: lambda { |ov| ov[:name].blank? || ov[:presentation].blank? }, allow_destroy: true
   end
 end

data/app/models/spree/option_value.rb

@@ -1,8 +1,10 @@
 module Spree
   class OptionValue < ActiveRecord::Base
     belongs_to :option_type
-    acts_as_list :scope => :option_type
-    has_and_belongs_to_many :variants, :join_table => 'spree_option_values_variants', :class_name => "Spree::Variant"
+    acts_as_list scope: :option_type
+    has_and_belongs_to_many :variants, join_table: 'spree_option_values_variants', class_name: "Spree::Variant"
+
+    validates :name, :presentation, presence: true
 
     attr_accessible :name, :presentation
   end

data/app/models/spree/order/checkout.rb

@@ -19,8 +19,7 @@ module Spree
           end
 
           def self.define_state_machine!
-            # Needs to be an ordered hash to preserve flow order
-            self.checkout_steps = ActiveSupport::OrderedHash.new
+            self.checkout_steps = {}
             self.next_event_transitions = []
             self.previous_states = [:cart]
             self.removed_transitions = []
@@ -72,14 +71,12 @@ module Spree
                 end
               end
 
-              before_transition :to => :delivery, :do => :remove_invalid_shipments!
+              before_transition :to => :delivery, :do => :create_proposed_shipments
 
               after_transition :to => :complete, :do => :finalize!
               after_transition :to => :delivery, :do => :create_tax_charge!
               after_transition :to => :resumed,  :do => :after_resume
               after_transition :to => :canceled, :do => :after_cancel
-
-              after_transition :from => :delivery,  :do => :create_shipment!
             end
           end
 
@@ -145,7 +142,7 @@ module Spree
           end
 
           def self.checkout_steps
-            @checkout_steps ||= ActiveSupport::OrderedHash.new
+            @checkout_steps ||= {}
           end
 
           def self.add_transition(options)