spree_core 3.0.10 → 3.1.0.rc1

data/app/models/spree/return_authorization.rb

@@ -1,22 +1,23 @@
 module Spree
   class ReturnAuthorization < Spree::Base
+    include Spree::Core::NumberGenerator.new(prefix: 'RA', length: 9)
+
     belongs_to :order, class_name: 'Spree::Order', inverse_of: :return_authorizations
 
     has_many :return_items, inverse_of: :return_authorization, dependent: :destroy
-    has_many :inventory_units, through: :return_items
-    has_many :customer_returns, through: :return_items
+    with_options through: :return_items do
+      has_many :inventory_units
+      has_many :customer_returns
+    end
 
     belongs_to :stock_location
     belongs_to :reason, class_name: 'Spree::ReturnAuthorizationReason', foreign_key: :return_authorization_reason_id
-    before_create :generate_number
 
     after_save :generate_expedited_exchange_reimbursements
 
     accepts_nested_attributes_for :return_items, allow_destroy: true
 
-    validates :order, presence: true
-    validates :reason, presence: true
-    validates :stock_location, presence: true
+    validates :order, :reason, :stock_location, presence: true
     validate :must_have_shipped_units, on: :create
 
 
@@ -37,7 +38,7 @@ module Spree
     extend DisplayMoney
     money_methods :pre_tax_total
 
-    self.whitelisted_ransackable_attributes = ['memo']
+    self.whitelisted_ransackable_attributes = ['memo', 'number', 'state']
 
     def pre_tax_total
       return_items.sum(:pre_tax_amount)
@@ -67,12 +68,6 @@ module Spree
         end
       end
 
-      def generate_number
-        self.number ||= loop do
-          random = "RA#{Array.new(9){rand(9)}.join}"
-          break random unless self.class.exists?(number: random)
-        end
-      end
 
       def cancel_return_items
         return_items.each { |item| item.cancel! if item.can_cancel? }

data/app/models/spree/return_authorization_reason.rb

@@ -2,6 +2,6 @@ module Spree
   class ReturnAuthorizationReason < Spree::Base
     include Spree::NamedType
 
-    has_many :return_authorizations
+    has_many :return_authorizations, dependent: :restrict_with_error
   end
 end

data/app/models/spree/return_item.rb

@@ -11,12 +11,14 @@ module Spree
     class_attribute :refund_amount_calculator
     self.refund_amount_calculator = Calculator::Returns::DefaultRefundAmount
 
-    belongs_to :return_authorization, inverse_of: :return_items
-    belongs_to :inventory_unit, inverse_of: :return_items
+    with_options inverse_of: :return_items do
+      belongs_to :return_authorization
+      belongs_to :inventory_unit
+      belongs_to :customer_return
+      belongs_to :reimbursement
+    end
     belongs_to :exchange_variant, class_name: 'Spree::Variant'
     belongs_to :exchange_inventory_unit, class_name: 'Spree::InventoryUnit', inverse_of: :original_return_item
-    belongs_to :customer_return, inverse_of: :return_items
-    belongs_to :reimbursement, inverse_of: :return_items
     belongs_to :preferred_reimbursement_type, class_name: 'Spree::ReimbursementType'
     belongs_to :override_reimbursement_type, class_name: 'Spree::ReimbursementType'
 
@@ -166,8 +168,11 @@ module Spree
 
     def process_inventory_unit!
       inventory_unit.return!
-
-      Spree::StockMovement.create!(stock_item_id: stock_item.id, quantity: 1) if should_restock?
+      Spree::StockMovement.create!(
+        stock_item_id: stock_item.id,
+        quantity: 1,
+        originator: return_authorization
+      ) if should_restock?
     end
 
     # This logic is also present in the customer return. The reason for the
@@ -220,12 +225,8 @@ module Spree
     end
 
     def cancel_others
-      Spree::ReturnItem.where(inventory_unit_id: inventory_unit_id)
-                       .where.not(id: id)
-                       .where.not(reception_status: 'cancelled')
-                       .each do |return_item|
-        return_item.cancel!
-      end
+      Spree::ReturnItem.where(inventory_unit_id: inventory_unit_id).where.not(id: id).
+        not_cancelled.each(&:cancel!)
     end
 
     def should_restock?

data/app/models/spree/return_item/eligibility_validator/time_since_purchase.rb

@@ -1,7 +1,7 @@
 module Spree
   class ReturnItem::EligibilityValidator::TimeSincePurchase < Spree::ReturnItem::EligibilityValidator::BaseValidator
     def eligible_for_return?
-      if (@return_item.inventory_unit.order.completed_at + Spree::Config[:return_eligibility_number_of_days].days) > Time.now
+      if (@return_item.inventory_unit.order.completed_at + Spree::Config[:return_eligibility_number_of_days].days) > Time.current
         return true
       else
         add_error(:number_of_days, Spree.t('return_item_time_period_ineligible'))

data/app/models/spree/role.rb

@@ -1,7 +1,8 @@
 module Spree
   class Role < Spree::Base
-    has_and_belongs_to_many :users, join_table: 'spree_roles_users', class_name: Spree.user_class.to_s
+    has_many :role_users, class_name: 'Spree::RoleUser', dependent: :destroy
+    has_many :users, through: :role_users, class_name: Spree.user_class.to_s
 
-    validates :name, presence: true
+    validates :name, presence: true, uniqueness: { allow_blank: true }
   end
 end

data/app/models/spree/role_user.rb

@@ -0,0 +1,6 @@
+module Spree
+  class RoleUser < Spree::Base
+    belongs_to :role, class_name: 'Spree::Role'
+    belongs_to :user, class_name: Spree.user_class
+  end
+end

data/app/models/spree/shipment.rb

@@ -2,24 +2,22 @@ require 'ostruct'
 
 module Spree
   class Shipment < Spree::Base
+    include Spree::Core::NumberGenerator.new(prefix: 'H', length: 11)
+
     extend FriendlyId
     friendly_id :number, slug_column: :number, use: :slugged
 
-    include Spree::NumberGenerator
-
-    def generate_number(options = {})
-      options[:prefix] ||= 'H'
-      options[:length] ||= 11
-      super(options)
+    with_options inverse_of: :shipments do
+      belongs_to :address, class_name: 'Spree::Address'
+      belongs_to :order, class_name: 'Spree::Order', touch: true
     end
-
-    belongs_to :address, class_name: 'Spree::Address', inverse_of: :shipments
-    belongs_to :order, class_name: 'Spree::Order', touch: true, inverse_of: :shipments
     belongs_to :stock_location, class_name: 'Spree::StockLocation'
 
-    has_many :adjustments, as: :adjustable, dependent: :delete_all
-    has_many :inventory_units, dependent: :delete_all, inverse_of: :shipment
-    has_many :shipping_rates, -> { order('cost ASC') }, dependent: :delete_all
+    with_options dependent: :delete_all do
+      has_many :adjustments, as: :adjustable
+      has_many :inventory_units, inverse_of: :shipment
+      has_many :shipping_rates, -> { order(:cost) }
+    end
     has_many :shipping_methods, through: :shipping_rates
     has_many :state_changes, as: :stateful
 
@@ -67,10 +65,7 @@ module Spree
 
       event :resume do
         transition from: :canceled, to: :ready, if: lambda { |shipment|
-          shipment.determine_state(shipment.order) == :ready
-        }
-        transition from: :canceled, to: :pending, if: lambda { |shipment|
-          shipment.determine_state(shipment.order) == :ready
+          shipment.determine_state(shipment.order) == 'ready'
         }
         transition from: :canceled, to: :pending
       end
@@ -120,7 +115,7 @@ module Spree
       return 'canceled' if order.canceled?
       return 'pending' unless order.can_ship?
       return 'pending' if inventory_units.any? &:backordered?
-      return 'shipped' if state == 'shipped'
+      return 'shipped' if shipped?
       order.paid? || Spree::Config[:auto_capture_on_dispatch] ? 'ready' : 'pending'
     end
 
@@ -143,7 +138,7 @@ module Spree
 
     def finalize!
       InventoryUnit.finalize_units!(inventory_units)
-      manifest.each { |item| manifest_unstock(item) }
+      after_resume
     end
 
     def include?(variant)
@@ -175,7 +170,7 @@ module Spree
         units.group_by(&:line_item_id).map do |line_item_id, units|
 
           states = {}
-          units.group_by(&:state).each { |state, iu| states[state] = iu.count }
+          units.group_by(&:state).each { |state, iu| states[state] = iu.size }
 
           line_item = units.first.line_item
           variant = units.first.variant
@@ -259,7 +254,7 @@ module Spree
 
     def shipped=(value)
       return unless value == '1' && shipped_at.nil?
-      self.shipped_at = Time.now
+      self.shipped_at = Time.current
     end
 
     def shipping_method
@@ -294,7 +289,7 @@ module Spree
         self.update_columns(
           cost: selected_shipping_rate.cost,
           adjustment_total: adjustments.additional.map(&:update!).compact.sum,
-          updated_at: Time.now,
+          updated_at: Time.current,
         )
       end
     end
@@ -316,7 +311,7 @@ module Spree
           # (via Order#paid?) affects the shipment state (YAY)
           self.update_columns(
             state: determine_state(order),
-            updated_at: Time.now
+            updated_at: Time.current
           )
 
           # And then it's time to update shipment states and finally persist
@@ -337,7 +332,7 @@ module Spree
       new_state = determine_state(order)
       update_columns(
         state: new_state,
-        updated_at: Time.now,
+        updated_at: Time.current,
       )
       after_ship if new_state == 'shipped' and old_state != 'shipped'
     end

data/app/models/spree/shipment_handler.rb

@@ -5,7 +5,7 @@ module Spree
         # Do we have a specialized shipping-method-specific handler? e.g:
         # Given shipment.shipping_method = Spree::ShippingMethod::DigitalDownload
         # do we have Spree::ShipmentHandler::DigitalDownload?
-        if sm_handler = "Spree::ShipmentHandler::#{shipment.shipping_method.name.split('::').last}".constantize rescue false
+        if sm_handler = "Spree::ShipmentHandler::#{shipment.shipping_method.name.split('::').last}".safe_constantize
           sm_handler.new(shipment)
         else
           new(shipment)
@@ -36,7 +36,7 @@ module Spree
         new_state = OrderUpdater.new(order).update_shipment_state
         order.update_columns(
                              shipment_state: new_state,
-                             updated_at: Time.now,
+                             updated_at: Time.current,
                              )
       end
   end

data/app/models/spree/shipping_category.rb

@@ -1,8 +1,11 @@
 module Spree
   class ShippingCategory < Spree::Base
-    validates :name, presence: true
-    has_many :products, inverse_of: :shipping_category
-    has_many :shipping_method_categories, inverse_of: :shipping_category
+    validates :name, presence: true, uniqueness: { allow_blank: true }
+
+    with_options inverse_of: :shipping_category do
+      has_many :products
+      has_many :shipping_method_categories
+    end
     has_many :shipping_methods, through: :shipping_method_categories
   end
 end

data/app/models/spree/shipping_method.rb

@@ -11,16 +11,16 @@ module Spree
 
     default_scope { where(deleted_at: nil) }
 
-    has_many :shipping_method_categories, :dependent => :destroy
+    has_many :shipping_method_categories, dependent: :destroy
     has_many :shipping_categories, through: :shipping_method_categories
     has_many :shipping_rates, inverse_of: :shipping_method
-    has_many :shipments, :through => :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'
+    has_many :shipping_method_zones, class_name: 'Spree::ShippingMethodZone',
+                                     foreign_key: 'shipping_method_id'
+    has_many :zones, through: :shipping_method_zones, class_name: 'Spree::Zone'
 
-    belongs_to :tax_category, :class_name => 'Spree::TaxCategory'
+    belongs_to :tax_category, class_name: 'Spree::TaxCategory'
 
     validates :name, presence: true
 
@@ -59,10 +59,11 @@ module Spree
     end
 
     private
-      def at_least_one_shipping_category
-        if self.shipping_categories.empty?
-          self.errors[:base] << "You need to select at least one shipping category"
-        end
+
+    def at_least_one_shipping_category
+      if shipping_categories.empty?
+        errors.add(:base, :required_shipping_category)
       end
+    end
   end
 end

data/app/models/spree/shipping_method_zone.rb

@@ -0,0 +1,6 @@
+module Spree
+  class ShippingMethodZone < Spree::Base
+    belongs_to :shipping_method
+    belongs_to :zone
+  end
+end

data/app/models/spree/shipping_rate.rb

@@ -6,50 +6,37 @@ module Spree
 
     delegate :order, :currency, to: :shipment
     delegate :name, to: :shipping_method
+    delegate :code, to: :shipping_method, prefix: true
 
-    def display_base_price
-      Spree::Money.new(cost, currency: currency)
-    end
+    extend Spree::DisplayMoney
+
+    money_methods :base_price, :tax_amount
 
-    def calculate_tax_amount
-      tax_rate.calculator.compute_shipping_rate(self)
+    def base_price
+      cost
     end
 
     def display_price
       price = display_base_price.to_s
-      if tax_rate
-        tax_amount = calculate_tax_amount
-        if tax_amount != 0
-          if tax_rate.included_in_price?
-            if tax_amount > 0
-              amount = "#{display_tax_amount(tax_amount)} #{tax_rate.name}"
-              price += " (#{Spree.t(:incl)} #{amount})"
-            else
-              amount = "#{display_tax_amount(tax_amount*-1)} #{tax_rate.name}"
-              price += " (#{Spree.t(:excl)} #{amount})"
-            end
-          else
-            amount = "#{display_tax_amount(tax_amount)} #{tax_rate.name}"
-            price += " (+ #{amount})"
-          end
-        end
-      end
-      price
+
+      return price if tax_rate.nil? || tax_amount == 0
+
+      Spree.t tax_rate.included_in_price? ? :including_tax : :excluding_tax,
+              scope: "shipping_rates.display_price",
+              price: price,
+              tax_amount: display_tax_amount,
+              tax_rate_name: tax_rate.name
     end
     alias_method :display_cost, :display_price
 
-    def display_tax_amount(tax_amount)
-      Spree::Money.new(tax_amount, currency: currency)
+    def tax_amount
+      @_tax_amount ||= tax_rate.calculator.compute_shipping_rate(self)
     end
 
     def shipping_method
       Spree::ShippingMethod.unscoped { super }
     end
 
-    def shipping_method_code
-      shipping_method.code
-    end
-
     def tax_rate
       Spree::TaxRate.unscoped { super }
     end

data/app/models/spree/state.rb

@@ -1,7 +1,7 @@
 module Spree
   class State < Spree::Base
     belongs_to :country, class_name: 'Spree::Country'
-    has_many :addresses, dependent: :nullify
+    has_many :addresses, dependent: :restrict_with_error
 
     has_many :zone_members,
              -> { where(zoneable_type: 'Spree::State') },
@@ -12,6 +12,7 @@ module Spree
     has_many :zones, through: :zone_members, class_name: 'Spree::Zone'
 
     validates :country, :name, presence: true
+    validates :name, :abbr, uniqueness: { case_sensitive: false, scope: :country_id }, allow_blank: true
 
     self.whitelisted_ransackable_attributes = %w(abbr)
 
@@ -23,7 +24,7 @@ module Spree
     # blank is added elsewhere, if needed
     def self.states_group_by_country_id
       state_info = Hash.new { |h, k| h[k] = [] }
-      self.order('name ASC').each { |state|
+      self.order(:name).each { |state|
         state_info[state.country_id.to_s].push [state.id, state.name]
       }
       state_info

data/app/models/spree/state_change.rb

@@ -1,6 +1,6 @@
 module Spree
   class StateChange < Spree::Base
-    belongs_to :user, class_name: Spree.user_class.to_s
+    belongs_to :user, class_name: Spree.user_class
     belongs_to :stateful, polymorphic: true
 
     def <=>(other)

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

@@ -8,16 +8,17 @@ module Spree
         @state = state
       end
 
-      def variant
-        inventory_unit.variant
+      with_options allow_nil: true do
+        delegate :line_item,
+                 :variant, to: :inventory_unit
+        delegate :price, to: :variant
+        delegate :dimension,
+                 :volume,
+                 :weight, to: :variant, prefix: true
       end
 
       def weight
-        variant.weight * quantity
-      end
-
-      def line_item
-        inventory_unit.line_item
+        variant_weight * quantity
       end
 
       def on_hand?
@@ -28,9 +29,6 @@ module Spree
         state.to_s == "backordered"
       end
 
-      def price
-        variant.price
-      end
 
       def amount
         price * quantity
@@ -45,11 +43,11 @@ module Spree
       end
 
       def volume
-        variant.volume * quantity
+        variant_volume * quantity
       end
 
       def dimension
-        variant.dimension * quantity
+        variant_dimension * quantity
       end
     end
   end