spree_core 3.0.9 → 3.2.0

data/app/models/spree/adjustable/adjuster/promotion.rb

@@ -0,0 +1,41 @@
+module Spree
+  module Adjustable
+    module Adjuster
+      class Promotion < Spree::Adjustable::Adjuster::Base
+        def update
+          promo_adjustments = adjustments.competing_promos.reload.map { |a| a.update!(adjustable) }
+          promos_total = promo_adjustments.compact.sum
+          choose_best_promo_adjustment unless promos_total == 0
+          promo_total = best_promo_adjustment.try(:amount).to_f if best_promo_adjustment.try(:promotion?)
+
+          update_totals(promo_total)
+        end
+
+        private
+
+        # Picks one (and only one) competing discount to be eligible for
+        # this order. This adjustment provides the most discount, and if
+        # two adjustments have the same amount, then it will pick the
+        # latest one.
+        def choose_best_promo_adjustment
+          if best_promo_adjustment
+            other_promotions = adjustments.competing_promos.where.not(id: best_promo_adjustment.id)
+            other_promotions.update_all(eligible: false)
+          end
+        end
+
+        def best_promo_adjustment
+          @best_promo_adjustment ||= begin
+            adjustments.competing_promos.eligible.reorder("amount ASC, created_at DESC, id DESC").first
+          end
+        end
+
+        def update_totals(promo_total)
+          promo_total ||= 0.0
+          @totals[:promo_total] = promo_total
+          @totals[:taxable_adjustment_total] += promo_total
+        end
+      end
+    end
+  end
+end

data/app/models/spree/adjustable/adjuster/tax.rb

@@ -0,0 +1,26 @@
+module Spree
+  module Adjustable
+    module Adjuster
+      class Tax < Spree::Adjustable::Adjuster::Base
+        def update
+          tax = adjustments.tax
+          included_tax_total = tax.is_included.reload.map(&:update!).compact.sum
+          additional_tax_total = tax.additional.reload.map(&:update!).compact.sum
+
+          update_totals(included_tax_total, additional_tax_total)
+        end
+
+        private
+
+        def adjustments
+          adjustable.try(:all_adjustments) || adjustable.adjustments
+        end
+
+        def update_totals(included_tax_total, additional_tax_total)
+          @totals[:included_tax_total] = included_tax_total
+          @totals[:additional_tax_total] = additional_tax_total
+        end
+      end
+    end
+  end
+end

data/app/models/spree/adjustable/adjustments_updater.rb

@@ -7,63 +7,40 @@ module Spree
 
       def initialize(adjustable)
         @adjustable = adjustable
-        adjustable.reload if shipment? && persisted?
+        adjustable.reload if shipment? && adjustable.persisted?
       end
 
       def update
-        return unless persisted?
-        update_promo_adjustments
-        update_tax_adjustments
-        persist_totals
-      end
-
-      private
-
-      attr_reader :adjustable
-      delegate :adjustments, :persisted?, to: :adjustable
+        return unless @adjustable.persisted?
+
+        totals = {
+          non_taxable_adjustment_total: 0,
+          taxable_adjustment_total: 0
+        }
+        adjusters.each do |klass|
+          klass.adjust(@adjustable, totals)
+        end
 
-      def update_promo_adjustments
-        promo_adjustments = adjustments.competing_promos.reload.map { |a| a.update!(adjustable) }
-        promos_total = promo_adjustments.compact.sum
-        choose_best_promo_adjustment unless promos_total == 0
-        @promo_total = best_promo_adjustment.try(:amount).to_f
+        persist_totals totals
       end
 
-      def update_tax_adjustments
-        tax = (adjustable.try(:all_adjustments) || adjustable.adjustments).tax
-        @included_tax_total = tax.is_included.reload.map(&:update!).compact.sum
-        @additional_tax_total = tax.additional.reload.map(&:update!).compact.sum
-      end
+      private
 
-      def persist_totals
-        adjustable.update_columns(
-          promo_total: @promo_total,
-          included_tax_total: @included_tax_total,
-          additional_tax_total: @additional_tax_total,
-          adjustment_total: @promo_total + @additional_tax_total,
-          updated_at: Time.now
-        )
+      def persist_totals(totals)
+        attributes = totals
+        attributes[:adjustment_total] = totals[:non_taxable_adjustment_total] +
+                                        totals[:taxable_adjustment_total] +
+                                        totals[:additional_tax_total]
+        attributes[:updated_at] = Time.current
+        @adjustable.update_columns(totals)
       end
 
       def shipment?
-        adjustable.is_a?(Shipment)
+        @adjustable.is_a?(Shipment)
       end
 
-      # Picks one (and only one) competing discount to be eligible for
-      # this order. This adjustment provides the most discount, and if
-      # two adjustments have the same amount, then it will pick the
-      # latest one.
-      def choose_best_promo_adjustment
-        if best_promo_adjustment
-          other_promotions = adjustments.competing_promos.where.not(id: best_promo_adjustment.id)
-          other_promotions.update_all(eligible: false)
-        end
-      end
-
-      def best_promo_adjustment
-        @best_promo_adjustment ||= begin
-          adjustments.competing_promos.eligible.reorder("amount ASC, created_at DESC, id DESC").first
-        end
+      def adjusters
+        Rails.application.config.spree.adjusters
       end
     end
   end

data/app/models/spree/adjustment.rb

@@ -22,13 +22,13 @@
 # it might be reinstated.
 module Spree
   class Adjustment < Spree::Base
-    belongs_to :adjustable, polymorphic: true, touch: true
-    belongs_to :source, polymorphic: true
+    with_options polymorphic: true do
+      belongs_to :adjustable, touch: true
+      belongs_to :source
+    end
     belongs_to :order, class_name: 'Spree::Order', inverse_of: :all_adjustments
 
-    validates :adjustable, presence: true
-    validates :order, presence: true
-    validates :label, presence: true
+    validates :adjustable, :order, :label, presence: true
     validates :amount, numericality: true
 
     state_machine :state, initial: :open do
@@ -67,14 +67,12 @@ module Spree
     scope :is_included, -> { where(included: true) }
     scope :additional, -> { where(included: false) }
     scope :competing_promos, -> { where(source_type: competing_promos_source_types) }
+    scope :for_complete_order, -> { joins(:order).merge(Spree::Order.complete) }
+    scope :for_incomplete_order, -> { joins(:order).merge(Spree::Order.incomplete) }
 
     extend DisplayMoney
     money_methods :amount
 
-    def closed?
-      state == "closed"
-    end
-
     def currency
       adjustable ? adjustable.currency : Spree::Config[:currency]
     end
@@ -89,7 +87,7 @@ module Spree
     def update!(target = adjustable)
       return amount if closed? || source.blank?
       amount = source.compute_amount(target)
-      attributes = { amount: amount, updated_at: Time.now }
+      attributes = { amount: amount, updated_at: Time.current }
       attributes[:eligible] = source.promotion.eligible?(target) if promotion?
       update_columns(attributes)
       amount

data/app/models/spree/app_configuration.rb

@@ -21,13 +21,21 @@ module Spree
   class AppConfiguration < Preferences::Configuration
     # Alphabetized to more easily lookup particular preferences
     preference :address_requires_state, :boolean, default: true # should state/state_name be required
-    preference :admin_interface_logo, :string, default: 'logo/spree_50.png'
-    preference :admin_products_per_page, :integer, default: 10
+    preference :admin_interface_logo, :string, default: 'admin/logo.png'
+    preference :admin_path, :string, default: '/admin'
+    preference :admin_products_per_page, :integer, default: Kaminari.config.default_per_page
+    preference :admin_orders_per_page, :integer, default: Kaminari.config.default_per_page
+    preference :admin_properties_per_page, :integer, default: Kaminari.config.default_per_page
+    preference :admin_promotions_per_page, :integer, default: Kaminari.config.default_per_page
+    preference :admin_customer_returns_per_page, :integer, default: Kaminari.config.default_per_page
+    preference :admin_users_per_page, :integer, default: Kaminari.config.default_per_page
+    preference :admin_show_version, :boolean, default: true
     preference :allow_checkout_on_gateway_error, :boolean, default: false
     preference :allow_guest_checkout, :boolean, default: true
     preference :alternative_shipping_phone, :boolean, default: false # Request extra phone for ship addr
     preference :always_include_confirm_step, :boolean, default: false # Ensures confirmation step is always in checkout_progress bar, but does not force a confirm step if your payment methods do not support it.
     preference :always_put_site_name_in_title, :boolean, default: true
+    preference :title_site_name_separator, :string, default: '-' # When always_put_site_name_in_title is true, insert a separator character before the site name in the title
     preference :auto_capture, :boolean, default: false # automatically capture the credit card (as opposed to just authorize and capture later)
     preference :auto_capture_on_dispatch, :boolean, default: false # Captures payment for each shipment in Shipment#after_ship callback, and makes Shipment.ready when payment authorized.
     preference :binary_inventory_cache, :boolean, default: false # only invalidate product cache when a stock item changes whether it is in_stock
@@ -40,14 +48,11 @@ module Spree
     preference :layout, :string, default: 'spree/layouts/spree_application'
     preference :logo, :string, default: 'logo/spree_50.png'
     preference :max_level_in_taxons_menu, :integer, default: 1 # maximum nesting level in taxons menu
-    preference :orders_per_page, :integer, default: 15
-    preference :properties_per_page, :integer, default: 15
     preference :products_per_page, :integer, default: 12
-    preference :promotions_per_page, :integer, default: 15
-    preference :customer_returns_per_page, :integer, default: 15
     preference :require_master_price, :boolean, default: true
     preference :restock_inventory, :boolean, default: true # Determines if a return item is restocked automatically once it has been received
     preference :return_eligibility_number_of_days, :integer, default: 365
+    preference :send_core_emails, :boolean, default: true # Default mail headers settings
     preference :shipping_instructions, :boolean, default: false # Request instructions/info for shipping
     preference :show_only_complete_orders_by_default, :boolean, default: true
     preference :show_variant_full_price, :boolean, default: false #Displays variant full price or difference with product price. Default false to be compatible with older behavior
@@ -56,8 +61,9 @@ module Spree
     preference :tax_using_ship_address, :boolean, default: true
     preference :track_inventory_levels, :boolean, default: true # Determines whether to track on_hand values for variants / products.
 
-    # Default mail headers settings
-    preference :send_core_emails, :boolean, default: true
+    # Store credits configurations
+    preference :non_expiring_credit_types, :array, default: []
+    preference :credit_to_new_allocation, :boolean, default: false
 
     # searcher_class allows spree extension writers to provide their own Search class
     def searcher_class

data/app/models/spree/base.rb

@@ -1,4 +1,4 @@
-class Spree::Base < ActiveRecord::Base
+class Spree::Base < ApplicationRecord
   include Spree::Preferences::Preferable
   serialize :preferences, Hash
 
@@ -17,4 +17,8 @@ class Spree::Base < ActiveRecord::Base
   end
 
   self.abstract_class = true
+
+  def self.spree_base_scopes
+    where(nil)
+  end
 end

data/app/models/spree/calculator/default_tax.rb

@@ -2,6 +2,7 @@ require_dependency 'spree/calculator'
 
 module Spree
   class Calculator::DefaultTax < Calculator
+    include VatPriceCalculation
     def self.description
       Spree.t(:default_tax)
     end
@@ -38,11 +39,7 @@ module Spree
     def compute_shipping_rate(shipping_rate)
       if rate.included_in_price
         pre_tax_amount = shipping_rate.cost / (1 + rate.amount)
-        if rate.zone == shipping_rate.shipment.order.tax_zone
-          deduced_total_by_rate(pre_tax_amount, rate)
-        else
-          deduced_total_by_rate(pre_tax_amount, rate) * - 1
-        end
+        deduced_total_by_rate(pre_tax_amount, rate)
       else
         with_tax_amount = shipping_rate.cost * rate.amount
         round_to_two_places(with_tax_amount)
@@ -55,13 +52,8 @@ module Spree
       self.calculable
     end
 
-    def round_to_two_places(amount)
-      BigDecimal.new(amount.to_s).round(2, BigDecimal::ROUND_HALF_UP)
-    end
-
     def deduced_total_by_rate(pre_tax_amount, rate)
       round_to_two_places(pre_tax_amount * rate.amount)
     end
-
   end
 end

data/app/models/spree/calculator/free_shipping.rb

@@ -1,7 +1,3 @@
-# TODO: Deprecate this class.
-# This calculator will be removed in future versions of Spree.
-# The only case where it was used was for Free Shipping Promotions.
-# There is now a Promotion Action which deals with these types of promotions instead.
 module Spree
   class Calculator::FreeShipping < Calculator
     def self.description
@@ -9,6 +5,11 @@ module Spree
     end
 
     def compute(object)
+      ActiveSupport::Deprecation.warn(<<-EOS, caller)
+        Spree::Calculator::FreeShipping will be removed in Spree 3.3
+        The only case where it was used was for Free Shipping Promotions.
+        There is now a Promotion Action which deals with these types of promotions instead
+      EOS
       if object.is_a?(Array)
         return if object.empty?
         order = object.first.order
@@ -19,4 +20,4 @@ module Spree
       order.ship_total
     end
   end
-end
+end

data/app/models/spree/calculator.rb

@@ -1,7 +1,7 @@
 module Spree
   class Calculator < Spree::Base
     # Conditional check for backwards compatibilty since acts as paranoid was added late https://github.com/spree/spree/issues/5858
-    if connection.table_exists?(:spree_calculators) && connection.column_exists?(:spree_calculators, :deleted_at)
+    if connection.data_source_exists?(:spree_calculators) && connection.column_exists?(:spree_calculators, :deleted_at)
       acts_as_paranoid
     end
 
@@ -27,11 +27,6 @@ module Spree
       'Base Calculator'
     end
 
-    ###################################################################
-
-    def self.register(*klasses)
-    end
-
     # Returns all calculators applicable for kind of work
     def self.calculators
       Rails.application.config.spree.calculators

data/app/models/spree/classification.rb

@@ -2,10 +2,14 @@ module Spree
   class Classification < Spree::Base
     self.table_name = 'spree_products_taxons'
     acts_as_list scope: :taxon
-    belongs_to :product, class_name: "Spree::Product", inverse_of: :classifications, touch: true
-    belongs_to :taxon, class_name: "Spree::Taxon", inverse_of: :classifications, touch: true
 
+    with_options inverse_of: :classifications, touch: true do
+      belongs_to :product, class_name: "Spree::Product"
+      belongs_to :taxon, class_name: "Spree::Taxon"
+    end
+
+    validates :taxon, :product, presence: true
     # For #3494
-    validates_uniqueness_of :taxon_id, scope: :product_id, message: :already_linked
+    validates :taxon_id, uniqueness: { scope: :product_id, message: :already_linked, allow_blank: true }
   end
 end

data/app/models/spree/country.rb

@@ -1,8 +1,11 @@
 module Spree
   class Country < Spree::Base
-    has_many :states, -> { order('name ASC') }, dependent: :destroy
-    has_many :addresses, dependent: :nullify
+    # we need to have this callback before any dependent: :destroy associations
+    # https://github.com/rails/rails/issues/3458
+    before_destroy :ensure_not_default
 
+    has_many :states, dependent: :destroy
+    has_many :addresses, dependent: :restrict_with_error
     has_many :zone_members,
              -> { where(zoneable_type: 'Spree::Country') },
              class_name: 'Spree::ZoneMember',
@@ -11,7 +14,7 @@ module Spree
 
     has_many :zones, through: :zone_members, class_name: 'Spree::Zone'
 
-    validates :name, :iso_name, presence: true
+    validates :name, :iso_name, presence: true, uniqueness: { case_sensitive: false, allow_blank: true }
 
     def self.default
       country_id = Spree::Config[:default_country_id]
@@ -25,5 +28,14 @@ module Spree
     def to_s
       name
     end
+
+    private
+
+    def ensure_not_default
+      if id.eql?(Spree::Config[:default_country_id])
+        errors.add(:base, Spree.t(:default_country_cannot_be_deleted))
+        throw(:abort)
+      end
+    end
   end
 end

data/app/models/spree/credit_card.rb

@@ -1,5 +1,7 @@
 module Spree
   class CreditCard < Spree::Base
+    include ActiveMerchant::Billing::CreditCardMethods
+
     belongs_to :payment_method
     belongs_to :user, class_name: Spree.user_class, foreign_key: 'user_id'
     has_many :payments, as: :source
@@ -8,17 +10,23 @@ module Spree
 
     after_save :ensure_one_default
 
+    # As of rails 4.2 string columns always return strings, we can override it on model level.
+    attribute :month, ActiveRecord::Type::Integer.new
+    attribute :year,  ActiveRecord::Type::Integer.new
+
+    attr_reader :number
     attr_accessor :encrypted_data,
-                    :number,
-                    :imported,
-                    :verification_value
+                  :imported,
+                  :verification_value,
+                  :manual_entry
 
-    validates :month, :year, numericality: { only_integer: true }, if: :require_card_numbers?, on: :create
-    validates :number, presence: true, if: :require_card_numbers?, on: :create, unless: :imported
-    validates :name, presence: true, if: :require_card_numbers?, on: :create
-    validates :verification_value, presence: true, if: :require_card_numbers?, on: :create, unless: :imported
+    with_options if: :require_card_numbers?, on: :create do
+      validates :month, :year, numericality: { only_integer: true }
+      validates :number, :verification_value, presence: true, unless: :imported
+      validates :name, presence: true
+    end
 
-    scope :with_payment_profile, -> { where('gateway_customer_profile_id IS NOT NULL') }
+    scope :with_payment_profile, -> { where.not(gateway_customer_profile_id: nil) }
     scope :default, -> { where(default: true) }
 
     # needed for some of the ActiveMerchant gateways (eg. SagePay)
@@ -33,28 +41,20 @@ module Spree
     attr_accessor :track_data
 
     CARD_TYPES = {
-      visa: /^4[0-9]{12}(?:[0-9]{3})?$/,
-      master: /(^5[1-5][0-9]{14}$)|(^6759[0-9]{2}([0-9]{10})$)|(^6759[0-9]{2}([0-9]{12})$)|(^6759[0-9]{2}([0-9]{13})$)/,
-      diners_club: /^3(?:0[0-5]|[68][0-9])[0-9]{11}$/,
-      american_express: /^3[47][0-9]{13}$/,
-      discover: /^6(?:011|5[0-9]{2})[0-9]{12}$/,
-      jcb: /^(?:2131|1800|35\d{3})\d{11}$/
+      visa: /^4\d{12}(\d{3})?(\d{3})?$/,
+      master: /^(5[1-5]\d{4}|677189|222[1-9]\d{2}|22[3-9]\d{3}|2[3-6]\d{4}|27[01]\d{3}|2720\d{2})\d{10}$/,
+      discover: /^(6011|65\d{2}|64[4-9]\d)\d{12}|(62\d{14})$/,
+      american_express: /^3[47]\d{13}$/,
+      diners_club: /^3(0[0-5]|[68]\d)\d{11}$/,
+      jcb: /^35(28|29|[3-8]\d)\d{12}$/,
+      switch: /^6759\d{12}(\d{2,3})?$/,
+      solo: /^6767\d{12}(\d{2,3})?$/,
+      dankort: /^5019\d{12}$/,
+      maestro: /^(5[06-8]|6\d)\d{10,17}$/,
+      forbrugsforeningen: /^600722\d{10}$/,
+      laser: /^(6304|6706|6709|6771(?!89))\d{8}(\d{4}|\d{6,7})?$/
     }
 
-    # As of rails 4.2 string columns always return strings, perhaps we should
-    # change these to integer columns on db level
-    def month
-      if type_casted = super
-        type_casted.to_i
-      end
-    end
-
-    def year
-      if type_casted = super
-        type_casted.to_i
-      end
-    end
-
     def expiry=(expiry)
       return unless expiry.present?
 
@@ -65,7 +65,7 @@ module Spree
         [match[1], match[2]]
       end
       if self[:year]
-        self[:year] = "20" + self[:year] if self[:year].length == 2
+        self[:year] = "20#{ self[:year] }" if self[:year] / 100 == 0
         self[:year] = self[:year].to_i
       end
       self[:month] = self[:month].to_i if self[:month]
@@ -144,12 +144,12 @@ module Spree
 
     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,
+        number: number,
+        month: month,
+        year: year,
+        verification_value: verification_value,
+        first_name: first_name,
+        last_name: last_name,
       )
     end
 
@@ -161,9 +161,8 @@ module Spree
 
     def ensure_one_default
       if self.user_id && self.default
-        CreditCard.where(default: true).where.not(id: self.id).where(user_id: self.user_id).each do |ucc|
-          ucc.update_columns(default: false)
-        end
+        CreditCard.where(default: true, user_id: self.user_id).where.not(id: self.id)
+          .update_all(default: false)
       end
     end
   end

data/app/models/spree/customer_return.rb

@@ -1,5 +1,6 @@
 module Spree
   class CustomerReturn < Spree::Base
+    include Spree::Core::NumberGenerator.new(prefix: 'CR', length: 9)
     belongs_to :stock_location
 
     has_many :reimbursements, inverse_of: :customer_return
@@ -7,11 +8,8 @@ module Spree
     has_many :return_items, inverse_of: :customer_return
 
     after_create :process_return!
-    before_create :generate_number
-
-    validates :return_items, presence: true
-    validates :stock_location, presence: true
 
+    validates :return_items, :stock_location, presence: true
     validate :must_have_return_authorization, on: :create
     validate :return_items_belong_to_same_order
 
@@ -20,6 +18,10 @@ module Spree
     extend DisplayMoney
     money_methods pre_tax_total: { currency: Spree::Config[:currency] }
 
+    self.whitelisted_ransackable_attributes = ['number']
+
+    delegate :id, to: :order, prefix: true, allow_nil: true
+
     def completely_decided?
       !return_items.undecided.exists?
     end
@@ -34,9 +36,6 @@ module Spree
       return_items.first.inventory_unit.order
     end
 
-    def order_id
-      order.try(:id)
-    end
 
     def pre_tax_total
       return_items.sum(:pre_tax_amount)
@@ -54,20 +53,13 @@ module Spree
       end
     end
 
-    def generate_number
-      self.number ||= loop do
-        random = "CR#{Array.new(9){rand(9)}.join}"
-        break random unless self.class.exists?(number: random)
-      end
-    end
-
     def process_return!
       return_items.each(&:receive!)
       order.return! if order.all_inventory_units_returned?
     end
 
     def return_items_belong_to_same_order
-      if return_items.select { |return_item| return_item.inventory_unit.order_id != order_id }.any?
+      if return_items.any? { |return_item| return_item.inventory_unit.order_id != order_id }
         errors.add(:base, Spree.t(:return_items_cannot_be_associated_with_multiple_orders))
       end
     end

data/app/models/spree/gateway/bogus.rb

@@ -1,7 +1,7 @@
 module Spree
   class Gateway::Bogus < Gateway
     TEST_VISA = ['4111111111111111','4012888888881881','4222222222222']
-    TEST_MC   = ['5500000000000004','5555555555554444','5105105105105100']
+    TEST_MC   = ['5500000000000004','5555555555554444','5105105105105100','2223000010309703']
     TEST_AMEX = ['378282246310005','371449635398431','378734493671000','340000000000009']
     TEST_DISC = ['6011000000000004','6011111111111117','6011000990139424']
 
@@ -21,43 +21,43 @@ module Spree
       return if payment.source.has_payment_profile?
       # simulate the storage of credit card profile using remote service
       if success = VALID_CCS.include?(payment.source.number)
-        payment.source.update_attributes(:gateway_customer_profile_id => generate_profile_id(success))
+        payment.source.update_attributes(gateway_customer_profile_id: generate_profile_id(success))
       end
     end
 
     def authorize(money, credit_card, options = {})
       profile_id = credit_card.gateway_customer_profile_id
       if VALID_CCS.include? credit_card.number or (profile_id and profile_id.starts_with? 'BGS-')
-        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345', :avs_result => { :code => 'D' })
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345', avs_result: { code: 'D' })
       else
-        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', { :message => 'Bogus Gateway: Forced failure' }, :test => true)
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', { message: 'Bogus Gateway: Forced failure' }, test: true)
       end
     end
 
     def purchase(money, credit_card, options = {})
       profile_id = credit_card.gateway_customer_profile_id
       if VALID_CCS.include? credit_card.number  or (profile_id and profile_id.starts_with? 'BGS-')
-        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345', :avs_result => { :code => 'M' })
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345', avs_result: { code: 'M' })
       else
-        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', :message => 'Bogus Gateway: Forced failure', :test => true)
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', message: 'Bogus Gateway: Forced failure', test: true)
       end
     end
 
     def credit(money, credit_card, response_code, options = {})
-      ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345')
+      ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345')
     end
 
     def capture(money, authorization, gateway_options)
       if authorization == '12345'
-        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true)
+        ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true)
       else
-        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', :error => 'Bogus Gateway: Forced failure', :test => true)
+        ActiveMerchant::Billing::Response.new(false, 'Bogus Gateway: Forced failure', error: 'Bogus Gateway: Forced failure', test: true)
       end
 
     end
 
     def void(response_code, credit_card, options = {})
-      ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, :test => true, :authorization => '12345')
+      ActiveMerchant::Billing::Response.new(true, 'Bogus Gateway: Forced success', {}, test: true, authorization: '12345')
     end
 
     def cancel(_response_code)
@@ -82,8 +82,8 @@ module Spree
         record = true
         prefix = success ? 'BGS' : 'FAIL'
         while record
-          random = "#{prefix}-#{Array.new(6){rand(6)}.join}"
-          record = CreditCard.where(:gateway_customer_profile_id => random).first
+          random = "#{ prefix }-#{ Array.new(6) { rand(6) }.join }"
+          record = CreditCard.find_by(gateway_customer_profile_id: random)
         end
         random
       end