spree_core 3.0.2 → 3.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 7aeecb32436b2f2e63f695ae7f8e72e0fc5d3dff
-  data.tar.gz: d3d9c62816751345378389914b51d876ac8f2910
+  metadata.gz: cf4b040c67cbc697e8ff23b19862515ad3ec40e5
+  data.tar.gz: 4338ea645e72ff94a0a52ffa3531319f4e64824c
 SHA512:
-  metadata.gz: 36a03013620da8c4081e87c51c29722106df038560a5cc0da2a6c3d39e5441d073e7deb643c349aacf276d96fb0c53f6fa3bb880ba6082dcb5ef86add172c2ce
-  data.tar.gz: e7e6816d26ae750cc2c9b5faee24fe5814d280679758e77e271d9a35952dcb52eb85e4bd54fb9598a1ea0240426f4870a51eb29a3725457b4573381bbce1fcdb
+  metadata.gz: b68a89ef41087957b53b64bb1519040c52b9de295f6f4a0cee305f9e236bb2ecfdf474eb8f466eb0b6c80f525ebb76913db76bdddba44022e2d8732d48ba18a4
+  data.tar.gz: f223ee12cd500420b4c590d66918da99d69c0f1c46eaac008d18fa5164889aa2eeea266ff15867873291c6c54a78377ae1ad5befcaf321c2e2625e66089dcf44

data/app/helpers/spree/base_helper.rb

@@ -92,6 +92,7 @@ module Spree
     def define_image_method(style)
       self.class.send :define_method, "#{style}_image" do |product, *options|
         options = options.first || {}
+        options[:alt] ||= product.name
         if product.images.empty?
           if !product.is_a?(Spree::Variant) && !product.variant_images.empty?
             create_product_image_tag(product.variant_images.first, product, options, style)

data/app/models/spree/address.rb

@@ -135,7 +135,7 @@ module Spree
         return if !TwitterCldr::Shared::PostalCodes.territories.include?(country.iso.downcase.to_sym)
 
         postal_code = TwitterCldr::Shared::PostalCodes.for_territory(country.iso)
-        errors.add(:zipcode, :invalid) if !postal_code.valid?(zipcode.to_s)
+        errors.add(:zipcode, :invalid) if !postal_code.valid?(zipcode.to_s.strip)
       end
   end
 end

data/app/models/spree/order.rb

@@ -446,7 +446,7 @@ module Spree
     end
 
     def create_proposed_shipments
-      adjustments.shipping.delete_all
+      all_adjustments.shipping.delete_all
       shipments.destroy_all
       self.shipments = Spree::Stock::Coordinator.new(self).shipments
     end
@@ -595,7 +595,7 @@ module Spree
       if shipments.empty? || shipments.any? { |shipment| shipment.shipping_rates.blank? }
         # After this point, order redirects back to 'address' state and asks user to pick a proper address
         # Therefore, shipments are not necessary at this point.
-        shipments.delete_all
+        shipments.destroy_all
         errors.add(:base, Spree.t(:items_cannot_be_shipped)) and return false
       end
     end

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

@@ -1,338 +1,338 @@
 module Spree
   class Order < Spree::Base
     module Checkout
-      extend ActiveSupport::Concern
-
-      included do
-        class_attribute :next_event_transitions
-        class_attribute :previous_states
-        class_attribute :checkout_flow
-        class_attribute :checkout_steps
-        class_attribute :removed_transitions
-
-        self.checkout_steps ||= {}
-        self.next_event_transitions ||= []
-        self.previous_states ||= [:cart]
-        self.removed_transitions ||= []
-
-        def self.checkout_flow(&block)
-          if block_given?
-            @checkout_flow = block
-            define_state_machine!
-          else
-            @checkout_flow
+      def self.included(klass)
+        klass.class_eval do
+          class_attribute :next_event_transitions
+          class_attribute :previous_states
+          class_attribute :checkout_flow
+          class_attribute :checkout_steps
+          class_attribute :removed_transitions
+
+          self.checkout_steps ||= {}
+          self.next_event_transitions ||= []
+          self.previous_states ||= [:cart]
+          self.removed_transitions ||= []
+
+          def self.checkout_flow(&block)
+            if block_given?
+              @checkout_flow = block
+              define_state_machine!
+            else
+              @checkout_flow
+            end
           end
-        end
-
-        def self.define_state_machine!
-          self.checkout_steps = {}
-          self.next_event_transitions = []
-          self.previous_states = [:cart]
-          self.removed_transitions = []
 
-          # Build the checkout flow using the checkout_flow defined either
-          # within the Order class, or a decorator for that class.
-          #
-          # This method may be called multiple times depending on if the
-          # checkout_flow is re-defined in a decorator or not.
-          instance_eval(&checkout_flow)
-
-          klass = self
-
-          # To avoid a ton of warnings when the state machine is re-defined
-          StateMachines::Machine.ignore_method_conflicts = true
-          # To avoid multiple occurrences of the same transition being defined
-          # On first definition, state_machines will not be defined
-          state_machines.clear if respond_to?(:state_machines)
-          state_machine :state, initial: :cart, use_transactions: false, action: :save_state do
-            klass.next_event_transitions.each { |t| transition(t.merge(on: :next)) }
-
-            # Persist the state on the order
-            after_transition do |order, transition|
-              order.state = order.state
-              order.state_changes.create(
-                previous_state: transition.from,
-                next_state:     transition.to,
-                name:           'order',
-                user_id:        order.user_id
-              )
-              order.save
-            end
+          def self.define_state_machine!
+            self.checkout_steps = {}
+            self.next_event_transitions = []
+            self.previous_states = [:cart]
+            self.removed_transitions = []
+
+            # Build the checkout flow using the checkout_flow defined either
+            # within the Order class, or a decorator for that class.
+            #
+            # This method may be called multiple times depending on if the
+            # checkout_flow is re-defined in a decorator or not.
+            instance_eval(&checkout_flow)
+
+            klass = self
+
+            # To avoid a ton of warnings when the state machine is re-defined
+            StateMachines::Machine.ignore_method_conflicts = true
+            # To avoid multiple occurrences of the same transition being defined
+            # On first definition, state_machines will not be defined
+            state_machines.clear if respond_to?(:state_machines)
+            state_machine :state, initial: :cart, use_transactions: false, action: :save_state do
+              klass.next_event_transitions.each { |t| transition(t.merge(on: :next)) }
+
+              # Persist the state on the order
+              after_transition do |order, transition|
+                order.state = order.state
+                order.state_changes.create(
+                  previous_state: transition.from,
+                  next_state: transition.to,
+                  name: 'order',
+                  user_id: order.user_id
+                )
+                order.save
+              end
 
-            event :cancel do
-              transition to: :canceled, if: :allow_cancel?
-            end
+              event :cancel do
+                transition to: :canceled, if: :allow_cancel?
+              end
 
-            event :return do
-              transition to: :returned,
-                         from: [:complete, :awaiting_return, :canceled],
-                         if: :all_inventory_units_returned?
-            end
+              event :return do
+                transition to: :returned,
+                           from: [:complete, :awaiting_return, :canceled],
+                           if: :all_inventory_units_returned?
+              end
 
-            event :resume do
-              transition to: :resumed, from: :canceled, if: :canceled?
-            end
+              event :resume do
+                transition to: :resumed, from: :canceled, if: :canceled?
+              end
 
-            event :authorize_return do
-              transition to: :awaiting_return
-            end
+              event :authorize_return do
+                transition to: :awaiting_return
+              end
 
-            if states[:payment]
-              before_transition to: :complete do |order|
-                if order.payment_required? && order.payments.valid.empty?
-                  order.errors.add(:base, Spree.t(:no_payment_found))
-                  false
-                elsif order.payment_required?
-                  order.process_payments!
+              if states[:payment]
+                before_transition to: :complete do |order|
+                  if order.payment_required? && order.payments.valid.empty?
+                    order.errors.add(:base, Spree.t(:no_payment_found))
+                    false
+                  elsif order.payment_required?
+                    order.process_payments!
+                  end
                 end
+                after_transition to: :complete, do: :persist_user_credit_card
+                before_transition to: :payment, do: :set_shipments_cost
+                before_transition to: :payment, do: :create_tax_charge!
+                before_transition to: :payment, do: :assign_default_credit_card
               end
-              after_transition to: :complete, do: :persist_user_credit_card
-              before_transition to: :payment, do: :set_shipments_cost
-              before_transition to: :payment, do: :create_tax_charge!
-              before_transition to: :payment, do: :assign_default_credit_card
-            end
 
-            before_transition from: :cart, do: :ensure_line_items_present
+              before_transition from: :cart, do: :ensure_line_items_present
 
-            if states[:address]
-              before_transition from: :address, do: :create_tax_charge!
-              before_transition to: :address, do: :assign_default_addresses!
-              before_transition from: :address, do: :persist_user_address!
-            end
+              if states[:address]
+                before_transition from: :address, do: :create_tax_charge!
+                before_transition to: :address, do: :assign_default_addresses!
+                before_transition from: :address, do: :persist_user_address!
+              end
 
-            if states[:delivery]
-              before_transition to: :delivery, do: :create_proposed_shipments
-              before_transition to: :delivery, do: :ensure_available_shipping_rates
-              before_transition to: :delivery, do: :set_shipments_cost
-              before_transition from: :delivery, do: :apply_free_shipping_promotions
-            end
+              if states[:delivery]
+                before_transition to: :delivery, do: :create_proposed_shipments
+                before_transition to: :delivery, do: :ensure_available_shipping_rates
+                before_transition to: :delivery, do: :set_shipments_cost
+                before_transition from: :delivery, do: :apply_free_shipping_promotions
+              end
 
-            before_transition to: :resumed, do: :ensure_line_item_variants_are_not_deleted
-            before_transition to: :resumed, do: :ensure_line_items_are_in_stock
+              before_transition to: :resumed, do: :ensure_line_item_variants_are_not_deleted
+              before_transition to: :resumed, do: :ensure_line_items_are_in_stock
 
-            before_transition to: :complete, do: :ensure_line_item_variants_are_not_deleted
-            before_transition to: :complete, do: :ensure_line_items_are_in_stock
+              before_transition to: :complete, do: :ensure_line_item_variants_are_not_deleted
+              before_transition to: :complete, do: :ensure_line_items_are_in_stock
 
-            after_transition to: :complete, do: :finalize!
-            after_transition to: :resumed,  do: :after_resume
-            after_transition to: :canceled, do: :after_cancel
+              after_transition to: :complete, do: :finalize!
+              after_transition to: :resumed, do: :after_resume
+              after_transition to: :canceled, do: :after_cancel
 
-            after_transition from: any - :cart, to: any - [:confirm, :complete] do |order|
-              order.update_totals
-              order.persist_totals
+              after_transition from: any - :cart, to: any - [:confirm, :complete] do |order|
+                order.update_totals
+                order.persist_totals
+              end
             end
-          end
-
-          alias_method :save_state, :save
-        end
 
-        def self.go_to_state(name, options = {})
-          self.checkout_steps[name] = options
-          previous_states.each do |state|
-            add_transition({ from: state, to: name }.merge(options))
+            alias_method :save_state, :save
           end
-          if options[:if]
-            previous_states << name
-          else
-            self.previous_states = [name]
-          end
-        end
 
-        def self.insert_checkout_step(name, options = {})
-          before = options.delete(:before)
-          after = options.delete(:after) unless before
-          after = self.checkout_steps.keys.last unless before || after
-
-          cloned_steps = self.checkout_steps.clone
-          cloned_removed_transitions = self.removed_transitions.clone
-          checkout_flow do
-            cloned_steps.each_pair do |key, value|
-              go_to_state(name, options) if key == before
-              go_to_state(key, value)
-              go_to_state(name, options) if key == after
+          def self.go_to_state(name, options = {})
+            self.checkout_steps[name] = options
+            previous_states.each do |state|
+              add_transition({ from: state, to: name }.merge(options))
             end
-            cloned_removed_transitions.each do |transition|
-              remove_transition(transition)
+            if options[:if]
+              previous_states << name
+            else
+              self.previous_states = [name]
             end
           end
-        end
 
-        def self.remove_checkout_step(name)
-          cloned_steps = self.checkout_steps.clone
-          cloned_removed_transitions = self.removed_transitions.clone
-          checkout_flow do
-            cloned_steps.each_pair do |key, value|
-              go_to_state(key, value) unless key == name
+          def self.insert_checkout_step(name, options = {})
+            before = options.delete(:before)
+            after = options.delete(:after) unless before
+            after = self.checkout_steps.keys.last unless before || after
+
+            cloned_steps = self.checkout_steps.clone
+            cloned_removed_transitions = self.removed_transitions.clone
+            checkout_flow do
+              cloned_steps.each_pair do |key, value|
+                go_to_state(name, options) if key == before
+                go_to_state(key, value)
+                go_to_state(name, options) if key == after
+              end
+              cloned_removed_transitions.each do |transition|
+                remove_transition(transition)
+              end
             end
-            cloned_removed_transitions.each do |transition|
-              remove_transition(transition)
+          end
+
+          def self.remove_checkout_step(name)
+            cloned_steps = self.checkout_steps.clone
+            cloned_removed_transitions = self.removed_transitions.clone
+            checkout_flow do
+              cloned_steps.each_pair do |key, value|
+                go_to_state(key, value) unless key == name
+              end
+              cloned_removed_transitions.each do |transition|
+                remove_transition(transition)
+              end
             end
           end
-        end
 
-        def self.remove_transition(options = {})
-          self.removed_transitions << options
-          self.next_event_transitions.delete(find_transition(options))
-        end
+          def self.remove_transition(options = {})
+            self.removed_transitions << options
+            self.next_event_transitions.delete(find_transition(options))
+          end
 
-        def self.find_transition(options = {})
-          return nil if options.nil? || !options.include?(:from) || !options.include?(:to)
-          self.next_event_transitions.detect do |transition|
-            transition[options[:from].to_sym] == options[:to].to_sym
+          def self.find_transition(options = {})
+            return nil if options.nil? || !options.include?(:from) || !options.include?(:to)
+            self.next_event_transitions.detect do |transition|
+              transition[options[:from].to_sym] == options[:to].to_sym
+            end
           end
-        end
 
-        def self.checkout_step_names
-          self.checkout_steps.keys
-        end
+          def self.checkout_step_names
+            self.checkout_steps.keys
+          end
 
-        def self.add_transition(options)
-          self.next_event_transitions << { options.delete(:from) => options.delete(:to) }.merge(options)
-        end
+          def self.add_transition(options)
+            self.next_event_transitions << { options.delete(:from) => options.delete(:to) }.merge(options)
+          end
 
-        def checkout_steps
-          steps = (self.class.checkout_steps.each_with_object([]) do |(step, options), checkout_steps|
-            next if options.include?(:if) && !options[:if].call(self)
-            checkout_steps << step
-          end).map(&:to_s)
-          # Ensure there is always a complete step
-          steps << "complete" unless steps.include?("complete")
-          steps
-        end
+          def checkout_steps
+            steps = (self.class.checkout_steps.each_with_object([]) do |(step, options), checkout_steps|
+              next if options.include?(:if) && !options[:if].call(self)
+              checkout_steps << step
+            end).map(&:to_s)
+            # Ensure there is always a complete step
+            steps << "complete" unless steps.include?("complete")
+            steps
+          end
 
-        def has_checkout_step?(step)
-          step.present? && self.checkout_steps.include?(step)
-        end
+          def has_checkout_step?(step)
+            step.present? && self.checkout_steps.include?(step)
+          end
 
-        def passed_checkout_step?(step)
-          has_checkout_step?(step) && checkout_step_index(step) < checkout_step_index(state)
-        end
+          def passed_checkout_step?(step)
+            has_checkout_step?(step) && checkout_step_index(step) < checkout_step_index(state)
+          end
 
-        def checkout_step_index(step)
-          self.checkout_steps.index(step).to_i
-        end
+          def checkout_step_index(step)
+            self.checkout_steps.index(step).to_i
+          end
 
-        def can_go_to_state?(state)
-          return false unless has_checkout_step?(self.state) && has_checkout_step?(state)
-          checkout_step_index(state) > checkout_step_index(self.state)
-        end
+          def can_go_to_state?(state)
+            return false unless has_checkout_step?(self.state) && has_checkout_step?(state)
+            checkout_step_index(state) > checkout_step_index(self.state)
+          end
 
-        define_callbacks :updating_from_params, terminator: ->(_target, result) { result == false }
+          define_callbacks :updating_from_params, terminator: ->(_target, result) { result == false }
 
-        set_callback :updating_from_params, :before, :update_params_payment_source
+          set_callback :updating_from_params, :before, :update_params_payment_source
 
-        def update_from_params(params, permitted_params, request_env = {})
-          success = false
-          @updating_params = params
-          run_callbacks :updating_from_params do
-            # Set existing card after setting permitted parameters because
-            # rails would slice parameters containg ruby objects, apparently
-            existing_card_id = @updating_params[:order] ? @updating_params[:order].delete(:existing_card) : nil
+          def update_from_params(params, permitted_params, request_env = {})
+            success = false
+            @updating_params = params
+            run_callbacks :updating_from_params do
+              # Set existing card after setting permitted parameters because
+              # rails would slice parameters containg ruby objects, apparently
+              existing_card_id = @updating_params[:order] ? @updating_params[:order].delete(:existing_card) : nil
 
-            attributes = @updating_params[:order] ? @updating_params[:order].permit(permitted_params).delete_if { |_k, v| v.nil? } : {}
+              attributes = @updating_params[:order] ? @updating_params[:order].permit(permitted_params).delete_if { |_k, v| v.nil? } : {}
 
-            if existing_card_id.present?
-              credit_card = CreditCard.find existing_card_id
-              if credit_card.user_id != user_id || credit_card.user_id.blank?
-                raise Core::GatewayError.new Spree.t(:invalid_credit_card)
-              end
+              if existing_card_id.present?
+                credit_card = CreditCard.find existing_card_id
+                if credit_card.user_id != user_id || credit_card.user_id.blank?
+                  raise Core::GatewayError.new Spree.t(:invalid_credit_card)
+                end
 
-              credit_card.verification_value = params[:cvc_confirm] if params[:cvc_confirm].present?
+                credit_card.verification_value = params[:cvc_confirm] if params[:cvc_confirm].present?
 
-              attributes[:payments_attributes].first[:source] = credit_card
-              attributes[:payments_attributes].first[:payment_method_id] = credit_card.payment_method_id
-              attributes[:payments_attributes].first.delete :source_attributes
-            end
+                attributes[:payments_attributes].first[:source] = credit_card
+                attributes[:payments_attributes].first[:payment_method_id] = credit_card.payment_method_id
+                attributes[:payments_attributes].first.delete :source_attributes
+              end
+
+              if attributes[:payments_attributes]
+                attributes[:payments_attributes].first[:request_env] = request_env
+              end
 
-            if attributes[:payments_attributes]
-              attributes[:payments_attributes].first[:request_env] = request_env
+              success = update_attributes(attributes)
+              set_shipments_cost if shipments.any?
             end
 
-            success = update_attributes(attributes)
-            set_shipments_cost if shipments.any?
+            @updating_params = nil
+            success
           end
 
-          @updating_params = nil
-          success
-        end
+          def assign_default_addresses!
+            if user
+              clone_billing
+              # Skip setting ship address if order doesn't have a delivery checkout step
+              # to avoid triggering validations on shipping address
+              clone_shipping if checkout_steps.include?("delivery")
+            end
+          end
 
-        def assign_default_addresses!
-          if user
-            clone_billing
-            # Skip setting ship address if order doesn't have a delivery checkout step
-            # to avoid triggering validations on shipping address
-            clone_shipping if checkout_steps.include?("delivery")
+          def clone_billing
+            if !bill_address_id && user.bill_address.try(:valid?)
+              self.bill_address = user.bill_address.try(:clone)
+            end
           end
-        end
 
-        def clone_billing
-          if !bill_address_id && user.bill_address.try(:valid?)
-            self.bill_address = user.bill_address.try(:clone)
+          def clone_shipping
+            if !ship_address_id && user.ship_address.try(:valid?)
+              self.ship_address = user.ship_address.try(:clone)
+            end
           end
-        end
 
-        def clone_shipping
-          if !ship_address_id && user.ship_address.try(:valid?)
-            self.ship_address = user.ship_address.try(:clone)
+          def persist_user_address!
+            if !temporary_address && user && user.respond_to?(:persist_order_address) && bill_address_id
+              user.persist_order_address(self)
+            end
           end
-        end
 
-        def persist_user_address!
-          if !temporary_address && user && user.respond_to?(:persist_order_address) && bill_address_id
-            user.persist_order_address(self)
+          def persist_user_credit_card
+            if !temporary_credit_card && user_id && valid_credit_cards.present?
+              default_cc = valid_credit_cards.first
+              default_cc.user_id = user_id
+              default_cc.default = true
+              default_cc.save
+            end
           end
-        end
 
-        def persist_user_credit_card
-          if !temporary_credit_card && user_id && valid_credit_cards.present?
-            default_cc = valid_credit_cards.first
-            default_cc.user_id = user_id
-            default_cc.default = true
-            default_cc.save
+          def assign_default_credit_card
+            if payments.from_credit_card.count == 0 && user_has_valid_default_card? && payment_required?
+              cc = user.default_credit_card
+              payments.create!(payment_method_id: cc.payment_method_id, source: cc, amount: total)
+            end
           end
-        end
 
-        def assign_default_credit_card
-          if payments.from_credit_card.count == 0 && user_has_valid_default_card? && payment_required?
-            cc = user.default_credit_card
-            payments.create!(payment_method_id: cc.payment_method_id, source: cc, amount: total)
+          def user_has_valid_default_card?
+            user && user.default_credit_card.try(:valid?)
           end
-        end
 
-        def user_has_valid_default_card?
-          user && user.default_credit_card.try(:valid?)
-        end
+          private
 
-        private
-
-        # For payment step, filter order parameters to produce the expected nested
-        # attributes for a single payment and its source, discarding attributes
-        # for payment methods other than the one selected
-        #
-        # In case a existing credit card is provided it needs to build the payment
-        # attributes from scratch so we can set the amount. example payload:
-        #
-        #   {
-        #     "order": {
-        #       "existing_card": "2"
-        #     }
-        #   }
-        #
-        def update_params_payment_source
-          if @updating_params[:payment_source].present?
-            source_params = @updating_params.
-                            delete(:payment_source)[@updating_params[:order][:payments_attributes].
-                                                    first[:payment_method_id].to_s]
-
-            if source_params
-              @updating_params[:order][:payments_attributes].first[:source_attributes] = source_params
+          # For payment step, filter order parameters to produce the expected nested
+          # attributes for a single payment and its source, discarding attributes
+          # for payment methods other than the one selected
+          #
+          # In case a existing credit card is provided it needs to build the payment
+          # attributes from scratch so we can set the amount. example payload:
+          #
+          #   {
+          #     "order": {
+          #       "existing_card": "2"
+          #     }
+          #   }
+          #
+          def update_params_payment_source
+            if @updating_params[:payment_source].present?
+              source_params = @updating_params.
+                              delete(:payment_source)[@updating_params[:order][:payments_attributes].
+                                                      first[:payment_method_id].to_s]
+
+              if source_params
+                @updating_params[:order][:payments_attributes].first[:source_attributes] = source_params
+              end
             end
-          end
 
-          if @updating_params[:order] && (@updating_params[:order][:payments_attributes] ||
-                                          @updating_params[:order][:existing_card])
-            @updating_params[:order][:payments_attributes] ||= [{}]
-            @updating_params[:order][:payments_attributes].first[:amount] = total
+            if @updating_params[:order] && (@updating_params[:order][:payments_attributes] ||
+                                            @updating_params[:order][:existing_card])
+              @updating_params[:order][:payments_attributes] ||= [{}]
+              @updating_params[:order][:payments_attributes].first[:amount] = total
+            end
           end
         end
       end

data/config/locales/en.yml

@@ -421,6 +421,7 @@ en:
         overview: Overview
         products: Products
         promotions: Promotions
+        promotion_categories: Promotion Categories
         properties: Properties
         prototypes: Prototypes
         reports: Reports

data/db/default/spree/countries.rb

@@ -26,4 +26,4 @@ connection.execute <<-SQL
   VALUES (#{country_values.call});
 SQL
 
-Spree::Config[:default_country_id] = Spree::Country.find_by(name: "United States").id
+Spree::Config[:default_country_id] = Spree::Country.find_by(iso: "US").id

data/db/default/spree/zones.rb

@@ -1,17 +1,12 @@
 eu_vat = Spree::Zone.create!(name: "EU_VAT", description: "Countries that make up the EU VAT zone.")
 north_america = Spree::Zone.create!(name: "North America", description: "USA + Canada")
-
-["Poland", "Finland", "Portugal", "Romania", "Germany", "France",
- "Slovakia", "Hungary", "Slovenia", "Ireland", "Austria", "Spain",
- "Italy", "Belgium", "Sweden", "Latvia", "Bulgaria", "United Kingdom",
- "Lithuania", "Cyprus", "Luxembourg", "Malta", "Denmark", "Netherlands",
- "Estonia"].
+%w(PL FI PT RO DE FR SK HU SI IE AT ES IT BE SE LV BG GB LT CY LU MT DK NL EE).
 each do |name|
-  eu_vat.zone_members.create!(zoneable: Spree::Country.find_by!(name: name))
+  eu_vat.zone_members.create!(zoneable: Spree::Country.find_by!(iso: name))
 end
 
-["United States", "Canada"].each do |name|
-  north_america.zone_members.create!(zoneable: Spree::Country.find_by!(name: name))
+%w(US CA).each do |name|
+  north_america.zone_members.create!(zoneable: Spree::Country.find_by!(iso: name))
 end
 
 

data/lib/spree/core/version.rb

@@ -1,5 +1,5 @@
 module Spree
   def self.version
-    '3.0.2'
+    '3.0.3'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spree_core
 version: !ruby/object:Gem::Version
-  version: 3.0.2
+  version: 3.0.3
 platform: ruby
 authors:
 - Sean Schofield
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-20 00:00:00.000000000 Z
+date: 2015-07-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activemerchant