spree_core 2.0.13 → 2.1.0

data/app/models/spree/order_contents.rb

@@ -8,14 +8,14 @@ module Spree
 
     # Get current line item for variant if exists
     # Add variant qty to line_item
-    def add(variant, quantity=1, currency=nil, shipment=nil)
+    def add(variant, quantity = 1, currency = nil, shipment = nil)
       line_item = order.find_line_item_by_variant(variant)
       add_to_line_item(line_item, variant, quantity, currency, shipment)
     end
 
     # Get current line item for variant
     # Remove variant qty from line_item
-    def remove(variant, quantity=1, shipment=nil)
+    def remove(variant, quantity = 1, shipment = nil)
       line_item = order.find_line_item_by_variant(variant)
 
       unless line_item
@@ -32,21 +32,18 @@ module Spree
         line_item.target_shipment = shipment
         line_item.quantity += quantity.to_i
         line_item.currency = currency unless currency.nil?
-        line_item.save
       else
-        line_item = LineItem.new(quantity: quantity)
+        line_item = order.line_items.new(quantity: quantity, variant: variant)
         line_item.target_shipment = shipment
-        line_item.variant = variant
         if currency
           line_item.currency = currency unless currency.nil?
           line_item.price    = variant.price_in(currency).amount
         else
           line_item.price    = variant.price
         end
-        order.line_items << line_item
-        line_item
       end
 
+      line_item.save
       order.reload
       line_item
     end

data/app/models/spree/order_inventory.rb

@@ -32,7 +32,7 @@ module Spree
     end
 
     def inventory_units_for(variant)
-      units = order.shipments.collect{|s| s.inventory_units.all}.flatten
+      units = order.shipments.collect{|s| s.inventory_units.to_a}.flatten
       units.group_by(&:variant_id)[variant.id] || []
     end
 
@@ -65,14 +65,10 @@ module Spree
     end
 
     def add_to_shipment(shipment, variant, quantity)
-      if variant.should_track_inventory?
-        on_hand, back_order = shipment.stock_location.fill_status(variant, quantity)
+      on_hand, back_order = shipment.stock_location.fill_status(variant, quantity)
 
-        on_hand.times { shipment.set_up_inventory('on_hand', variant, order) }
-        back_order.times { shipment.set_up_inventory('backordered', variant, order) }
-      else
-        quantity.times { shipment.set_up_inventory('on_hand', variant, order) }
-      end
+      on_hand.times { shipment.set_up_inventory('on_hand', variant, order) }
+      back_order.times { shipment.set_up_inventory('backordered', variant, order) }
 
       # adding to this shipment, and removing from stock_location
       if order.completed?

data/app/models/spree/order_updater.rb

@@ -25,7 +25,8 @@ module Spree
         update_shipment_state
       end
       
-      update_adjustments
+      update_promotion_adjustments
+      update_shipping_adjustments
       # update totals a second time in case updated adjustments have an effect on the total
       update_totals
 
@@ -101,16 +102,10 @@ module Spree
     # The +payment_state+ value helps with reporting, etc. since it provides a quick and easy way to locate Orders needing attention.
     def update_payment_state
 
-      # line_item are empty when user empties cart
+      #line_item are empty when user empties cart
       if line_items.empty? || round_money(order.payment_total) < round_money(order.total)
-        if payments.present?
-          if payments.last.state == 'failed'
-            order.payment_state = 'failed'
-          elsif payments.last.state == 'completed'
-            order.payment_state = 'credit_owed'
-          else
-            order.payment_state = 'balance_due'
-          end
+        if payments.present? && payments.last.state == 'failed'
+          order.payment_state = 'failed'
         else
           order.payment_state = 'balance_due'
         end
@@ -130,11 +125,17 @@ module Spree
     #
     # Adjustments will check if they are still eligible. Ineligible adjustments
     # are preserved but not counted towards adjustment_total.
-    def update_adjustments
-      order.adjustments.reload.each { |adjustment| adjustment.update!(order) }
+    def update_promotion_adjustments
+      order.adjustments.reload.promotion.each { |adjustment| adjustment.update!(order) }
       choose_best_promotion_adjustment
     end
 
+    # Shipping adjustments don't receive order on update! because they calculated
+    # over a shipping / package object rather than an order object
+    def update_shipping_adjustments
+      order.adjustments.reload.shipping.each { |adjustment| adjustment.update! }
+    end
+
     private
 
       # Picks one (and only one) promotion to be eligible for this order

data/app/models/spree/payment/processing.rb

@@ -83,37 +83,30 @@ module Spree
 
           credit_amount ||= credit_allowed >= order.outstanding_balance.abs ? order.outstanding_balance.abs : credit_allowed.abs
           credit_amount = credit_amount.to_f
-          credit_cents = Spree::Money.new(credit_amount, currency: currency).money.cents
 
           if payment_method.payment_profiles_supported?
-            response = payment_method.credit(credit_cents, source, response_code, gateway_options)
+            response = payment_method.credit((credit_amount * 100).round, source, response_code, gateway_options)
           else
-            response = payment_method.credit(credit_cents, response_code, gateway_options)
+            response = payment_method.credit((credit_amount * 100).round, response_code, gateway_options)
           end
 
           record_response(response)
 
           if response.success?
-            self.class.create({ :order => order,
-                                :source => self,
-                                :payment_method => payment_method,
-                                :amount => credit_amount.abs * -1,
-                                :response_code => response.authorization,
-                                :state => 'completed' }, :without_protection => true)
+            self.class.create(
+              :order => order,
+              :source => self,
+              :payment_method => payment_method,
+              :amount => credit_amount.abs * -1,
+              :response_code => response.authorization,
+              :state => 'completed'
+            )
           else
             gateway_error(response)
           end
         end
       end
 
-      def cancel!
-        if payment_method.respond_to?(:cancel)
-          payment_method.cancel(response_code)
-        else
-          credit!
-        end
-      end
-
       def partial_credit(amount)
         return if amount > credit_allowed
         started_processing!
@@ -148,7 +141,7 @@ module Spree
         protect_from_connection_error do
           check_environment
 
-          response = payment_method.send(action, money.money.cents,
+          response = payment_method.send(action, (amount * 100).round,
                                          source,
                                          gateway_options)
           handle_response(response, success_state, :failure)
@@ -176,7 +169,7 @@ module Spree
       end
 
       def record_response(response)
-        log_entries.create({:details => response.to_yaml}, :without_protection => true)
+        log_entries.create(:details => response.to_yaml)
       end
 
       def protect_from_connection_error

data/app/models/spree/payment.rb

@@ -4,15 +4,16 @@ module Spree
 
     IDENTIFIER_CHARS = (('A'..'Z').to_a + ('0'..'9').to_a - %w(0 1 I O)).freeze
 
-    belongs_to :order, class_name: 'Spree::Order', touch: true
+    belongs_to :order, class_name: 'Spree::Order'
     belongs_to :source, polymorphic: true
     belongs_to :payment_method, class_name: 'Spree::PaymentMethod'
 
-    has_many :offsets, class_name: "Spree::Payment", foreign_key: :source_id, conditions: "source_type = 'Spree::Payment' AND amount < 0 AND state = 'completed'"
+    has_many :offsets, -> { where("source_type = 'Spree::Payment' AND amount < 0 AND state = 'completed'") },
+      class_name: "Spree::Payment", foreign_key: :source_id
     has_many :log_entries, as: :source
 
     before_validation :validate_source
-    before_create :set_unique_identifier
+    before_save :set_unique_identifier
 
     after_save :create_payment_profile, if: :profiles_supported?
 
@@ -24,49 +25,45 @@ module Spree
     attr_accessor :source_attributes
     after_initialize :build_source
 
-    attr_accessible :amount, :payment_method_id, :source_attributes
-
     scope :from_credit_card, -> { where(source_type: 'Spree::CreditCard') }
     scope :with_state, ->(s) { where(state: s.to_s) }
-    scope :completed, with_state('completed')
-    scope :pending, with_state('pending')
-    scope :failed, with_state('failed')
-    scope :valid, where("#{quoted_table_name}.state NOT IN (?)", %w(failed invalid))
+    scope :completed, -> { with_state('completed') }
+    scope :pending, -> { with_state('pending') }
+    scope :failed, -> { with_state('failed') }
+    scope :valid, -> { where('state NOT IN (?)', %w(failed invalid)) }
 
     after_rollback :persist_invalid
 
-    validates :amount, numericality: true
-
     def persist_invalid
       return unless ['failed', 'invalid'].include?(state)
       state_will_change!
-      save
+      save 
     end
 
     # order state machine (see http://github.com/pluginaweek/state_machine/tree/master for details)
-    state_machine initial: 'checkout' do
+    state_machine initial: :checkout do
       # With card payments, happens before purchase or authorization happens
       event :started_processing do
-        transition from: ['checkout', 'pending', 'completed', 'processing'], to: 'processing'
+        transition from: [:checkout, :pending, :completed, :processing], to: :processing
       end
       # When processing during checkout fails
       event :failure do
-        transition from: ['pending', 'processing'], to: 'failed'
+        transition from: [:pending, :processing], to: :failed
       end
       # With card payments this represents authorizing the payment
       event :pend do
-        transition from: ['checkout', 'processing'], to: 'pending'
+        transition from: [:checkout, :processing], to: :pending
       end
       # With card payments this represents completing a purchase or capture transaction
       event :complete do
-        transition from: ['processing', 'pending', 'checkout'], to: 'completed'
+        transition from: [:processing, :pending, :checkout], to: :completed
       end
       event :void do
-        transition from: ['pending', 'completed', 'checkout'], to: 'void'
+        transition from: [:pending, :completed, :checkout], to: :void
       end
       # when the card brand isnt supported
       event :invalidate do
-        transition from: ['checkout'], to: 'invalid'
+        transition from: [:checkout], to: :invalid
       end
     end
 
@@ -79,22 +76,12 @@ module Spree
     end
     alias display_amount money
 
-    def amount=(amount)
-      self[:amount] =
-        case amount
-        when String
-          separator = I18n.t('number.currency.format.separator')
-          number    = amount.delete("^0-9-#{separator}").tr(separator, '.')
-          number.to_d if number.present?
-        end || amount
-    end
-
     def offsets_total
       offsets.pluck(:amount).sum
     end
 
     def credit_allowed
-      amount - offsets_total.abs
+      amount - offsets_total
     end
 
     def can_credit?

data/app/models/spree/payment_method.rb

@@ -2,11 +2,10 @@ module Spree
   class PaymentMethod < ActiveRecord::Base
     acts_as_paranoid
     DISPLAY = [:both, :front_end, :back_end]
-    default_scope where(deleted_at: nil)
+    default_scope -> { where(deleted_at: nil) }
 
     scope :production, -> { where(environment: 'production') }
 
-    attr_accessible :name, :description, :environment, :display_on, :active
     validates :name, presence: true
 
     def self.providers
@@ -41,7 +40,7 @@ module Spree
     end
 
     def self.find_with_destroyed *args
-      self.with_exclusive_scope { find(*args) }
+      unscoped { find(*args) }
     end
 
     def payment_profiles_supported?

data/app/models/spree/preference.rb

@@ -1,5 +1,5 @@
 class Spree::Preference < ActiveRecord::Base
-  attr_accessible :key, :value_type, :value
+  serialize :value
 
   validates :key, presence: true
   validates :value_type, presence: true

data/app/models/spree/preferences/configuration.rb

@@ -29,7 +29,7 @@ module Spree::Preferences
     end
 
     def preference_cache_key(name)
-      [self.class.name, name].join('::').underscore
+      [ENV['RAILS_CACHE_ID'], self.class.name, name].flatten.join('::').underscore
     end
 
     def reset

data/app/models/spree/preferences/preferable.rb

@@ -78,7 +78,7 @@ module Spree::Preferences::Preferable
 
   def preference_cache_key(name)
     return unless id
-    [self.class.name, name, id].join('::').underscore
+    [ENV["RAILS_CACHE_ID"], self.class.name, name, id].join('::').underscore
   end
 
   def save_pending_preferences

data/app/models/spree/preferences/store.rb

@@ -86,7 +86,7 @@ module Spree::Preferences
     end
 
     def should_persist?
-      @persistence and Spree::Preference.table_exists?
+      @persistence && Spree::Preference.connected? && Spree::Preference.table_exists?
     end
 
   end

data/app/models/spree/price.rb

@@ -5,8 +5,6 @@ module Spree
     validate :check_price
     validates :amount, numericality: { greater_than_or_equal_to: 0 }, allow_nil: true
 
-    attr_accessible :variant_id, :currency, :amount
-
     def display_amount
       money
     end
@@ -24,11 +22,6 @@ module Spree
       self[:amount] = parse_price(price)
     end
 
-    # Remove variant default_scope `deleted_at: nil`
-    def variant
-      Spree::Variant.unscoped { super }
-    end
-
     private
     def check_price
       raise "Price must belong to a variant" if variant.nil?

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

@@ -24,7 +24,7 @@ module Spree
         next if name.to_s.include?("master_price")
         parts = name.to_s.match(/(.*)_by_(.*)/)
         order_text = "#{Product.quoted_table_name}.#{parts[2]} #{parts[1] == 'ascend' ?  "ASC" : "DESC"}"
-        self.scope(name.to_s, order(order_text))
+        self.scope(name.to_s, -> { relation.order(order_text) })
       end
     end
 
@@ -68,11 +68,14 @@ module Spree
     #
     #   SELECT COUNT(*) ...
     add_search_scope :in_taxon do |taxon|
-      select("spree_products.id, spree_products.*").
-      where(id: Classification.select('spree_products_taxons.product_id').
-            joins(:taxon).
-            where(Taxon.table_name => { :id => taxon.self_and_descendants.pluck(:id) })
-           )
+      if ActiveRecord::Base.connection.adapter_name == "PostgreSQL"
+        scope = select("DISTINCT ON (spree_products.id) spree_products.*")
+      else
+        scope = select("DISTINCT(spree_products.id), spree_products.*")
+      end
+
+      scope.joins(:taxons).
+      where(Taxon.table_name => { :id => taxon.self_and_descendants.map(&:id) })
     end
 
     # This scope selects products in all taxons AND all its descendants
@@ -124,20 +127,20 @@ module Spree
     add_search_scope :with_option_value do |option, value|
       option_values = OptionValue.table_name
       option_type_id = case option
-        when String then OptionType.find_by_name(option) || option.to_i
+        when String then OptionType.find_by(name: option) || option.to_i
         when OptionType then option.id
         else option.to_i
       end
 
       conditions = "#{option_values}.name = ? AND #{option_values}.option_type_id = ?", value, option_type_id
-      group("spree_products.id").joins(:variants_including_master => :option_values).where(conditions)
+      group('spree_products.id').joins(variants_including_master: :option_values).where(conditions)
     end
 
     # Finds all products which have either:
     # 1) have an option value with the name matching the one given
     # 2) have a product property with a value matching the one given
     add_search_scope :with do |value|
-      includes(:variants_including_master => :option_values).
+      includes(variants_including_master: :option_values).
       includes(:product_properties).
       where("#{OptionValue.table_name}.name = ? OR #{ProductProperty.table_name}.value = ?", value, value)
     end
@@ -160,7 +163,7 @@ module Spree
     # Finds all products that have the ids matching the given collection of ids.
     # Alternatively, you could use find(collection_of_ids), but that would raise an exception if one product couldn't be found
     add_search_scope :with_ids do |*ids|
-      where(:id => ids)
+      where(id: ids)
     end
 
     # Sorts products from most popular (popularity is extracted from how many
@@ -195,11 +198,7 @@ module Spree
 
     # Can't use add_search_scope for this as it needs a default argument
     def self.available(available_on = nil, currency = nil)
-      scope = joins(:master => :prices).where("#{Product.quoted_table_name}.available_on <= ?", available_on || Time.now)
-      unless Spree::Config.show_products_without_price
-        scope = scope.where('spree_prices.currency' => currency || Spree::Config[:currency]).where('spree_prices.amount IS NOT NULL')
-      end
-      scope
+      joins(:master => :prices).where("#{Product.quoted_table_name}.available_on <= ?", available_on || Time.now)
     end
     search_scopes << :available
 
@@ -249,10 +248,10 @@ module Spree
         taxons = Taxon.table_name
         ids_or_records_or_names.flatten.map { |t|
           case t
-          when Integer then Taxon.find_by_id(t)
+          when Integer then Taxon.find_by(id: t)
           when ActiveRecord::Base then t
           when String
-            Taxon.find_by_name(t) ||
+            Taxon.find_by(name: t) ||
             Taxon.where("#{taxons}.permalink LIKE ? OR #{taxons}.permalink = ?", "%/#{t}/", "#{t}/").first
           end
         }.compact.flatten.uniq

data/app/models/spree/product.rb

@@ -34,22 +34,22 @@ module Spree
     belongs_to :shipping_category, class_name: 'Spree::ShippingCategory'
 
     has_one :master,
+      -> { where is_master: true },
       class_name: 'Spree::Variant',
-      conditions: { is_master: true },
       dependent: :destroy
 
     has_many :variants,
-      class_name: 'Spree::Variant',
-      conditions: { is_master: false, deleted_at: nil },
-      order: "#{::Spree::Variant.quoted_table_name}.position ASC"
+      -> { where(is_master: false).order("#{::Spree::Variant.quoted_table_name}.position ASC") },
+      class_name: 'Spree::Variant'
 
     has_many :variants_including_master,
+      -> { order("#{::Spree::Variant.quoted_table_name}.position ASC") },
       class_name: 'Spree::Variant',
-      dependent: :destroy,
-      order: "#{::Spree::Variant.quoted_table_name}.position ASC"
+      dependent: :destroy
+
+    has_many :prices, -> { order('spree_variants.position, spree_variants.id, currency') }, through: :variants
 
-    has_many :prices, through: :variants, order: "#{::Spree::Variant.quoted_table_name}.position, #{::Spree::Variant.quoted_table_name}.id, #{::Spree::Price.quoted_table_name}.currency"
-    has_many :stock_items, through: :variants_including_master
+    has_many :stock_items, through: :variants
 
     delegate_belongs_to :master, :sku, :price, :currency, :display_amount, :display_price, :weight, :height, :width, :depth, :is_master, :has_default_price?, :cost_currency, :price_in, :amount_in
     delegate_belongs_to :master, :cost_price if Variant.table_exists? && Variant.column_names.include?('cost_price')
@@ -62,7 +62,7 @@ module Spree
     delegate :images, to: :master, prefix: true
     alias_method :images, :master_images
 
-    has_many :variant_images, source: :images, through: :variants_including_master, order: :position
+    has_many :variant_images, -> { order(:position) }, source: :images, through: :variants_including_master
 
     accepts_nested_attributes_for :variants, allow_destroy: true
 
@@ -73,31 +73,6 @@ module Spree
 
     attr_accessor :option_values_hash
 
-    attr_accessible :available_on,
-                    :cost_currency,
-                    :deleted_at,
-                    :depth,
-                    :description,
-                    :height,
-                    :meta_description,
-                    :meta_keywords,
-                    :name,
-                    :option_type_ids,
-                    :option_values_hash,
-                    :permalink,
-                    :price,
-                    :product_properties_attributes,
-                    :prototype_id,
-                    :shipping_category_id,
-                    :sku,
-                    :tax_category_id,
-                    :taxon_ids,
-                    :weight,
-                    :width,
-                    :variants_attributes
-
-    attr_accessible :cost_price if Variant.table_exists? && Variant.column_names.include?('cost_price')
-
     accepts_nested_attributes_for :product_properties, allow_destroy: true, reject_if: lambda { |pp| pp[:property_name].blank? }
 
     make_permalink order: :name
@@ -108,11 +83,6 @@ module Spree
 
     before_destroy :punch_permalink
 
-    def variants_with_only_master
-      ActiveSupport::Deprecation.warn("[SPREE] Spree::Product#variants_with_only_master will be deprecated in Spree 1.3. Please use Spree::Product#master instead.")
-      master
-    end
-
     def to_param
       permalink.present? ? permalink : (permalink_was || name.to_s.to_url)
     end
@@ -141,7 +111,7 @@ module Spree
       return if option_values_hash.nil?
       option_values_hash.keys.map(&:to_i).each do |id|
         self.option_type_ids << id unless option_type_ids.include?(id)
-        product_option_types.create({option_type_id: id}, without_protection: true) unless product_option_types.pluck(:option_type_id).include?(id)
+        product_option_types.create(option_type_id: id) unless product_option_types.pluck(:option_type_id).include?(id)
       end
     end
 
@@ -159,11 +129,8 @@ module Spree
       !!deleted_at
     end
 
-    # determine if product is available.
-    # deleted products and products with nil or future available_on date
-    # are not available
     def available?
-      !(available_on.nil? || available_on.future?) && !deleted?
+      !(available_on.nil? || available_on.future?)
     end
 
     # split variants list into hash which shows mapping of opt value onto matching variants
@@ -199,19 +166,14 @@ module Spree
     end
 
     def property(property_name)
-      return nil unless prop = properties.find_by_name(property_name)
-      product_properties.find_by_property_id(prop.id).try(:value)
+      return nil unless prop = properties.find_by(name: property_name)
+      product_properties.find_by(property: prop).try(:value)
     end
 
     def set_property(property_name, property_value)
       ActiveRecord::Base.transaction do
-        # Works around spree_i18n #301
-        property = if Property.exists?(name: property_name)
-          Property.where(name: property_name).first
-        else
-          Property.create(name: property_name, presentation: property_name)
-        end
-        product_property = ProductProperty.where(product_id: self.id, property_id: property.id).first_or_initialize
+        property = Property.where(name: property_name).first_or_create!(presentation: property_name)
+        product_property = ProductProperty.where(product: self, property: property).first_or_initialize
         product_property.value = property_value
         product_property.save!
       end
@@ -223,10 +185,10 @@ module Spree
     end
 
     def total_on_hand
-      if self.variants_including_master.any? { |v| !v.should_track_inventory? }
-        Float::INFINITY
-      else
+      if Spree::Config.track_inventory_levels
         self.stock_items.sum(&:count_on_hand)
+      else
+        Float::INFINITY
       end
     end
 
@@ -234,7 +196,7 @@ module Spree
     # which would make AR's default finder return nil.
     # This is a stopgap for that little problem.
     def master
-      super || variants_including_master.with_deleted.where(:is_master => true).first
+      super || variants_including_master.with_deleted.where(is_master: true).first
     end
 
     private
@@ -246,15 +208,18 @@ module Spree
         values = values.inject(values.shift) { |memo, value| memo.product(value).map(&:flatten) }
 
         values.each do |ids|
-          variant = variants.create({ option_value_ids: ids, price: master.price }, without_protection: true)
+          variant = variants.create(
+            option_value_ids: ids,
+            price: master.price
+          )
         end
         save
       end
 
       def add_properties_and_option_types_from_prototype
-        if prototype_id && prototype = Spree::Prototype.find_by_id(prototype_id)
+        if prototype_id && prototype = Spree::Prototype.find_by(id: prototype_id)
           prototype.properties.each do |property|
-            product_properties.create({property: property}, without_protection: true)
+            product_properties.create(property: property)
           end
           self.option_types = prototype.option_types
         end
@@ -268,7 +233,7 @@ module Spree
       # there's a weird quirk with the delegate stuff that does not automatically save the delegate object
       # when saving so we force a save using a hook.
       def save_master
-        master.save if master && (master.changed? || master.new_record? || (master.default_price && (master.default_price.changed? || master.default_price.new_record?)))
+        master.save if master && (master.changed? || master.new_record? || (master.default_price && (master.default_price.changed || master.default_price.new_record)))
       end
 
       def ensure_master
@@ -278,7 +243,7 @@ module Spree
 
       def punch_permalink
         update_attribute :permalink, "#{Time.now.to_i}_#{permalink}" # punch permalink with date prefix
-      end  
+      end
   end
 end