spree_frontend 3.0.2 → 3.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 56c38cf8ac7763562f329b9adc3fc02a6447bfc7
-  data.tar.gz: bb96d44f57de9e6aa5f5332a8890eb7c1c9c19cd
+  metadata.gz: 653f9c14b1a63ca204d89de7d6e2bf888d264717
+  data.tar.gz: 1863ba346f67cb4d96cbae63c5827c07e184cc16
 SHA512:
-  metadata.gz: 75d2017697863f14073f5f1a355caa6045eb96658191470e166772c9fb759eaf58606d9eb5c3280ec44bd5cb6be07dc81794a03170bc4955154dc7f84bea159e
-  data.tar.gz: 9fdea3dfa42e6715cbb26ad22c3260f0651470ca3eeaeac8a9c2f5625a46188c0df5d4e1d48064a8c11b9ed88da9978a015b5df187cf28a918fd12043af761de
+  metadata.gz: 0d2c0710cfb65b3d961a88f0502dddcc1e75d7aaf4988d8af1cede68d94b6fb4f21247f5e8f9ab4e34247de0295c4d77fd42194b54708bf5c71c0994e1436796
+  data.tar.gz: 0f8dc1d3e821a1a3d7afb7204f3cdd942ea1d4cd59be960b3902447f51605fd3ccf81d6ef040bd0c82fe38eedf965930c714f5d58bea0c3560aadc8f21040f95

data/app/controllers/spree/checkout_controller.rb

@@ -21,7 +21,7 @@ module Spree
 
     helper 'spree/orders'
 
-    rescue_from Spree::Core::GatewayError, :with => :rescue_from_spree_gateway_error
+    rescue_from Spree::Core::GatewayError, with: :rescue_from_spree_gateway_error
 
     # Updates the order and advances to the next state (when possible.)
     def update
@@ -29,7 +29,7 @@ module Spree
         @order.temporary_address = !params[:save_user_address]
         unless @order.next
           flash[:error] = @order.errors.full_messages.join("\n")
-          redirect_to checkout_state_path(@order.state) and return
+          redirect_to(checkout_state_path(@order.state)) && return
         end
 
         if @order.completed?
@@ -76,106 +76,120 @@ module Spree
       end
     end
 
-      # Should be overriden if you have areas of your checkout that don't match
-      # up to a step within checkout_steps, such as a registration step
-      def skip_state_validation?
-        false
-      end
+    # Should be overriden if you have areas of your checkout that don't match
+    # up to a step within checkout_steps, such as a registration step
+    def skip_state_validation?
+      false
+    end
 
-      def load_order_with_lock
-        @order = current_order(lock: true)
-        redirect_to spree.cart_path and return unless @order
-      end
+    def load_order_with_lock
+      @order = current_order(lock: true)
+      redirect_to(spree.cart_path) && return unless @order
+    end
 
-      def ensure_valid_state_lock_version
-        if params[:order] && params[:order][:state_lock_version]
-          @order.with_lock do
-            unless @order.state_lock_version == params[:order].delete(:state_lock_version).to_i
-              flash[:error] = Spree.t(:order_already_updated)
-              redirect_to checkout_state_path(@order.state) and return
-            end
-            @order.increment!(:state_lock_version)
+    def ensure_valid_state_lock_version
+      if params[:order] && params[:order][:state_lock_version]
+        @order.with_lock do
+          unless @order.state_lock_version == params[:order].delete(:state_lock_version).to_i
+            flash[:error] = Spree.t(:order_already_updated)
+            redirect_to(checkout_state_path(@order.state)) && return
           end
+          @order.increment!(:state_lock_version)
         end
       end
+    end
 
-      def set_state_if_present
-        if params[:state]
-          redirect_to checkout_state_path(@order.state) if @order.can_go_to_state?(params[:state]) && !skip_state_validation?
-          @order.state = params[:state]
-        end
-      end
-
-      def ensure_checkout_allowed
-        unless @order.checkout_allowed?
-          redirect_to spree.cart_path
+    def set_state_if_present
+      if params[:state]
+        if @order.can_go_to_state?(params[:state]) && !skip_state_validation?
+          redirect_to checkout_state_path(@order.state)
         end
+        @order.state = params[:state]
       end
+    end
 
-      def ensure_order_not_completed
-        redirect_to spree.cart_path if @order.completed?
+    def ensure_checkout_allowed
+      unless @order.checkout_allowed?
+        redirect_to spree.cart_path
       end
+    end
 
-      def ensure_sufficient_stock_lines
-        if @order.insufficient_stock_lines.present?
-          flash[:error] = Spree.t(:inventory_error_flash_for_insufficient_quantity)
-          redirect_to spree.cart_path
-        end
-      end
+    def ensure_order_not_completed
+      redirect_to spree.cart_path if @order.completed?
+    end
 
-      # Provides a route to redirect after order completion
-      def completion_route(custom_params = nil)
-        spree.order_path(@order, custom_params)
+    def ensure_sufficient_stock_lines
+      if @order.insufficient_stock_lines.present?
+        flash[:error] = Spree.t(:inventory_error_flash_for_insufficient_quantity)
+        redirect_to spree.cart_path
       end
+    end
 
-      def setup_for_current_state
-        method_name = :"before_#{@order.state}"
-        send(method_name) if respond_to?(method_name, true)
-      end
+    # Provides a route to redirect after order completion
+    def completion_route(custom_params = nil)
+      spree.order_path(@order, custom_params)
+    end
 
-      def before_address
-        # if the user has a default address, a callback takes care of setting
-        # that; but if he doesn't, we need to build an empty one here
-        @order.bill_address ||= Address.build_default
-        @order.ship_address ||= Address.build_default if @order.checkout_steps.include?('delivery')
-      end
+    def setup_for_current_state
+      method_name = :"before_#{@order.state}"
+      send(method_name) if respond_to?(method_name, true)
+    end
 
-      def before_delivery
-        return if params[:order].present?
+    def before_address
+      # if the user has a default address, a callback takes care of setting
+      # that; but if he doesn't, we need to build an empty one here
+      @order.bill_address ||= Address.build_default
+      @order.ship_address ||= Address.build_default if @order.checkout_steps.include?('delivery')
+    end
 
-        packages = @order.shipments.map { |s| s.to_package }
-        @differentiator = Spree::Stock::Differentiator.new(@order, packages)
-      end
+    def before_delivery
+      return if params[:order].present?
 
-      def before_payment
-        if @order.checkout_steps.include? "delivery"
-          packages = @order.shipments.map { |s| s.to_package }
-          @differentiator = Spree::Stock::Differentiator.new(@order, packages)
-          @differentiator.missing.each do |variant, quantity|
-            @order.contents.remove(variant, quantity)
-          end
+      packages = @order.shipments.map(&:to_package)
+      @differentiator = Spree::Stock::Differentiator.new(@order, packages)
+    end
 
-          # @order.contents.remove did transitively call reload in the past.
-          # Hiding the fact that the machine advanced already to "payment" state.
-          #
-          # As an intermediary step to optimize reloads out of high volume code path
-          # the reload was lifted here and will be removed by later passes.
-          @order.reload
+    def before_payment
+      if @order.checkout_steps.include? "delivery"
+        packages = @order.shipments.map(&:to_package)
+        @differentiator = Spree::Stock::Differentiator.new(@order, packages)
+        @differentiator.missing.each do |variant, quantity|
+          @order.contents.remove(variant, quantity)
         end
 
-        if try_spree_current_user && try_spree_current_user.respond_to?(:payment_sources)
-          @payment_sources = try_spree_current_user.payment_sources
-        end
+        # @order.contents.remove did transitively call reload in the past.
+        # Hiding the fact that the machine advanced already to "payment" state.
+        #
+        # As an intermediary step to optimize reloads out of high volume code path
+        # the reload was lifted here and will be removed by later passes.
+        @order.reload
       end
 
-      def rescue_from_spree_gateway_error(exception)
-        flash.now[:error] = Spree.t(:spree_gateway_error_flash_for_checkout)
-        @order.errors.add(:base, exception.message)
-        render :edit
+      if try_spree_current_user && try_spree_current_user.respond_to?(:payment_sources)
+        @payment_sources = try_spree_current_user.payment_sources
       end
+    end
 
-      def check_authorization
-        authorize!(:edit, current_order, cookies.signed[:guest_token])
-      end
+    def rescue_from_spree_gateway_error(exception)
+      flash.now[:error] = Spree.t(:spree_gateway_error_flash_for_checkout)
+      @order.errors.add(:base, exception.message)
+      render :edit
+    end
+
+    def check_authorization
+      authorize!(:edit, current_order, cookies.signed[:guest_token])
+    end
+
+    def sanitize_zip_code
+      order_params = params[:order]
+      return unless order_params
+      strip_zip(order_params[:bill_address_attributes])
+      strip_zip(order_params[:ship_address_attributes])
+    end
+
+    def strip_zip(address_params)
+      return unless address_params
+      address_params[:zipcode] = address_params[:zipcode].strip if address_params[:zipcode]
+    end
   end
 end

data/spec/controllers/spree/checkout_controller_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::CheckoutController, :type => :controller do
+describe Spree::CheckoutController, type: :controller do
   let(:token) { 'some_token' }
   let(:user) { stub_model(Spree::LegacyUser) }
   let(:order) { FactoryGirl.create(:order_with_totals) }
@@ -20,31 +20,31 @@ describe Spree::CheckoutController, :type => :controller do
     it 'should check if the user is authorized for :edit' do
       expect(controller).to receive(:authorize!).with(:edit, order, token)
       request.cookie_jar.signed[:guest_token] = token
-      spree_get :edit, { state: 'address' }
+      spree_get :edit, state: 'address'
     end
 
     it "should redirect to the cart path unless checkout_allowed?" do
-      allow(order).to receive_messages :checkout_allowed? => false
-      spree_get :edit, { :state => "delivery" }
+      allow(order).to receive_messages checkout_allowed?: false
+      spree_get :edit, state: "delivery"
       expect(response).to redirect_to(spree.cart_path)
     end
 
     it "should redirect to the cart path if current_order is nil" do
       allow(controller).to receive(:current_order).and_return(nil)
-      spree_get :edit, { :state => "delivery" }
+      spree_get :edit, state: "delivery"
       expect(response).to redirect_to(spree.cart_path)
     end
 
     it "should redirect to cart if order is completed" do
-      allow(order).to receive_messages(:completed? => true)
-      spree_get :edit, { :state => "address" }
+      allow(order).to receive_messages(completed?: true)
+      spree_get :edit, state: "address"
       expect(response).to redirect_to(spree.cart_path)
     end
 
     # Regression test for #2280
     it "should redirect to current step trying to access a future step" do
       order.update_column(:state, "address")
-      spree_get :edit, { :state => "delivery" }
+      spree_get :edit, state: "delivery"
       expect(response).to redirect_to spree.checkout_state_path("address")
     end
 
@@ -67,36 +67,38 @@ describe Spree::CheckoutController, :type => :controller do
     it 'should check if the user is authorized for :edit' do
       expect(controller).to receive(:authorize!).with(:edit, order, token)
       request.cookie_jar.signed[:guest_token] = token
-      spree_post :update, { state: 'address' }
+      spree_post :update, state: 'address'
     end
 
     context "save successful" do
       def spree_post_address
-        spree_post :update, {
-          :state => "address",
-          :order => {
-            :bill_address_attributes => address_params,
-            :use_billing => true
-          }
-        }
+        spree_post :update,
+                   state: "address",
+                   order: {
+                     bill_address_attributes: address_params,
+                     use_billing: true
+                   }
       end
 
       before do
         # Must have *a* shipping method and a payment method so updating from address works
-        allow(order).to receive_messages :available_shipping_methods => [stub_model(Spree::ShippingMethod)]
-        allow(order).to receive_messages :available_payment_methods => [stub_model(Spree::PaymentMethod)]
-        allow(order).to receive_messages :ensure_available_shipping_rates => true
+        allow(order).to receive(:available_shipping_methods).
+          and_return [stub_model(Spree::ShippingMethod)]
+        allow(order).to receive(:available_payment_methods).
+          and_return [stub_model(Spree::PaymentMethod)]
+        allow(order).to receive(:ensure_available_shipping_rates).
+          and_return true
         order.line_items << FactoryGirl.create(:line_item)
       end
 
       context "with the order in the cart state" do
         before do
           order.update_column(:state, "cart")
-          allow(order).to receive_messages :user => user
+          allow(order).to receive_messages user: user
         end
 
         it "should assign order" do
-          spree_post :update, {:state => "address"}
+          spree_post :update, state: "address"
           expect(assigns[:order]).not_to be_nil
         end
 
@@ -113,29 +115,27 @@ describe Spree::CheckoutController, :type => :controller do
         context "current_user respond to save address method" do
           it "calls persist order address on user" do
             expect(user).to receive(:persist_order_address)
-            spree_post :update, {
-              :state => "address",
-              :order => {
-                :bill_address_attributes => address_params,
-                :use_billing => true
-              },
-              :save_user_address => "1"
-            }
+            spree_post :update,
+                       state: "address",
+                       order: {
+                         bill_address_attributes: address_params,
+                         use_billing: true
+                       },
+                       save_user_address: "1"
           end
         end
 
         context "current_user doesnt respond to persist_order_address" do
           it "doesnt raise any error" do
-            expect {
-              spree_post :update, {
-                :state => "address",
-                :order => {
-                  :bill_address_attributes => address_params,
-                  :use_billing => true
-                },
-                :save_user_address => "1"
-              }
-            }.to_not raise_error
+            expect do
+              spree_post :update,
+                         state: "address",
+                         order: {
+                           bill_address_attributes: address_params,
+                           use_billing: true
+                         },
+                         save_user_address: "1"
+            end.to_not raise_error
           end
         end
       end
@@ -147,19 +147,28 @@ describe Spree::CheckoutController, :type => :controller do
         end
 
         context "with a billing and shipping address" do
+          let(:bill_address_params) do
+            order.bill_address.attributes.except("created_at", "updated_at")
+          end
+          let(:ship_address_params) do
+            order.ship_address.attributes.except("created_at", "updated_at")
+          end
+          let(:update_params) do
+            {
+              state: "address",
+              order: {
+                bill_address_attributes: bill_address_params,
+                ship_address_attributes: ship_address_params,
+                use_billing: false
+              }
+            }
+          end
+
           before do
             @expected_bill_address_id = order.bill_address.id
             @expected_ship_address_id = order.ship_address.id
 
-            spree_post :update, {
-                :state => "address",
-                :order => {
-                    :bill_address_attributes => order.bill_address.attributes.except("created_at", "updated_at"),
-                    :ship_address_attributes => order.ship_address.attributes.except("created_at", "updated_at"),
-                    :use_billing => false
-                }
-            }
-
+            spree_post :update, update_params
             order.reload
           end
 
@@ -172,28 +181,28 @@ describe Spree::CheckoutController, :type => :controller do
 
       context "when in the confirm state" do
         before do
-          allow(order).to receive_messages :confirmation_required? => true
+          allow(order).to receive_messages confirmation_required?: true
           order.update_column(:state, "confirm")
-          allow(order).to receive_messages :user => user
+          allow(order).to receive_messages user: user
           # An order requires a payment to reach the complete state
           # This is because payment_required? is true on the order
-          create(:payment, :amount => order.total, :order => order)
+          create(:payment, amount: order.total, order: order)
           order.payments.reload
         end
 
         # This inadvertently is a regression test for #2694
         it "should redirect to the order view" do
-          spree_post :update, {:state => "confirm"}
+          spree_post :update, state: "confirm"
           expect(response).to redirect_to spree.order_path(order)
         end
 
         it "should populate the flash message" do
-          spree_post :update, {:state => "confirm"}
+          spree_post :update, state: "confirm"
           expect(flash.notice).to eq(Spree.t(:order_processed_successfully))
         end
 
         it "should remove completed order from current_order" do
-          spree_post :update, {:state => "confirm"}, {:order_id => "foofah"}
+          spree_post :update, { state: "confirm" }, order_id: "foofah"
           expect(assigns(:current_order)).to be_nil
           expect(assigns(:order)).to eql controller.current_order
         end
@@ -201,7 +210,7 @@ describe Spree::CheckoutController, :type => :controller do
 
       # Regression test for #4190
       context "state_lock_version" do
-        let(:post_params) {
+        let(:post_params) do
           {
             state: "address",
             order: {
@@ -210,7 +219,7 @@ describe Spree::CheckoutController, :type => :controller do
               use_billing: true
             }
           }
-        }
+        end
 
         context "correct" do
           it "should properly update and increment version" do
@@ -245,44 +254,44 @@ describe Spree::CheckoutController, :type => :controller do
 
     context "save unsuccessful" do
       before do
-        allow(order).to receive_messages :user => user
-        allow(order).to receive_messages :update_attributes => false
+        allow(order).to receive_messages user: user
+        allow(order).to receive_messages update_attributes: false
       end
 
       it "should not assign order" do
-        spree_post :update, {:state => "address"}
+        spree_post :update, state: "address"
         expect(assigns[:order]).not_to be_nil
       end
 
       it "should not change the order state" do
-        spree_post :update, { :state => 'address' }
+        spree_post :update, state: 'address'
       end
 
       it "should render the edit template" do
-        spree_post :update, { :state => 'address' }
+        spree_post :update, state: 'address'
         expect(response).to render_template :edit
       end
     end
 
     context "when current_order is nil" do
-      before { allow(controller).to receive_messages :current_order => nil }
+      before { allow(controller).to receive_messages current_order: nil }
 
       it "should not change the state if order is completed" do
         expect(order).not_to receive(:update_attribute)
-        spree_post :update, {:state => "confirm"}
+        spree_post :update, state: "confirm"
       end
 
       it "should redirect to the cart_path" do
-        spree_post :update, {:state => "confirm"}
+        spree_post :update, state: "confirm"
         expect(response).to redirect_to spree.cart_path
       end
     end
 
     context "Spree::Core::GatewayError" do
       before do
-        allow(order).to receive_messages :user => user
+        allow(order).to receive_messages user: user
         allow(order).to receive(:update_attributes).and_raise(Spree::Core::GatewayError.new("Invalid something or other."))
-        spree_post :update, {:state => "address"}
+        spree_post :update, state: "address"
       end
 
       it "should render the edit template and display exception message" do
@@ -301,15 +310,15 @@ describe Spree::CheckoutController, :type => :controller do
       end
 
       before do
-        allow(controller).to receive_messages :current_order => order
-        allow(controller).to receive_messages :check_authorization => true
+        allow(controller).to receive_messages current_order: order
+        allow(controller).to receive_messages check_authorization: true
       end
 
       context "when the country is not a shippable country" do
         before do
           order.ship_address.tap do |address|
             # A different country which is not included in the list of shippable countries
-            address.country = FactoryGirl.create(:country, :name => "Australia")
+            address.country = FactoryGirl.create(:country, name: "Australia")
             address.state_name = 'Victoria'
             address.save
           end
@@ -319,7 +328,7 @@ describe Spree::CheckoutController, :type => :controller do
           expect(order.shipments.count).to eq(1)
           order.shipments.first.shipping_rates.delete_all
 
-          spree_put :update, state: order.state, :order => {}
+          spree_put :update, state: order.state, order: {}
           expect(flash[:error]).to eq(Spree.t(:items_cannot_be_shipped))
           expect(response).to redirect_to(spree.checkout_state_path('address'))
         end
@@ -333,7 +342,7 @@ describe Spree::CheckoutController, :type => :controller do
         end
 
         it "due to the order having errors" do
-          spree_put :update, state: order.state, :order => {}
+          spree_put :update, state: order.state, order: {}
           expect(flash[:error]).to eql("Base error\nAdjustments error")
           expect(response).to redirect_to(spree.checkout_state_path('address'))
         end
@@ -348,32 +357,32 @@ describe Spree::CheckoutController, :type => :controller do
           end
           # So that the confirmation step is skipped and we get straight to the action.
           payment_method = FactoryGirl.create(:simple_credit_card_payment_method)
-          payment = FactoryGirl.create(:payment, :payment_method => payment_method)
+          payment = FactoryGirl.create(:payment, payment_method: payment_method)
           order.payments << payment
         end
       end
 
       before do
-        allow(controller).to receive_messages :current_order => order
-        allow(controller).to receive_messages :check_authorization => true
+        allow(controller).to receive_messages current_order: order
+        allow(controller).to receive_messages check_authorization: true
       end
 
       it "when GatewayError is raised" do
         allow_any_instance_of(Spree::Payment).to receive(:process!).and_raise(Spree::Core::GatewayError.new(Spree.t(:payment_processing_failed)))
-        spree_put :update, state: order.state, :order => {}
+        spree_put :update, state: order.state, order: {}
         expect(flash[:error]).to eq(Spree.t(:payment_processing_failed))
       end
     end
   end
 
   context "When last inventory item has been purchased" do
-    let(:product) { mock_model(Spree::Product, :name => "Amazing Object") }
+    let(:product) { mock_model(Spree::Product, name: "Amazing Object") }
     let(:variant) { mock_model(Spree::Variant) }
-    let(:line_item) { mock_model Spree::LineItem, :insufficient_stock? => true, :amount => 0 }
+    let(:line_item) { mock_model Spree::LineItem, insufficient_stock?: true, amount: 0 }
     let(:order) { create(:order) }
 
     before do
-      allow(order).to receive_messages(:line_items => [line_item], :state => "payment")
+      allow(order).to receive_messages(line_items: [line_item], state: "payment")
 
       configure_spree_preferences do |config|
         config.track_inventory_levels = true
@@ -382,7 +391,7 @@ describe Spree::CheckoutController, :type => :controller do
 
     context "and back orders are not allowed" do
       before do
-        spree_post :update, { :state => "payment" }
+        spree_post :update, state: "payment"
       end
 
       it "should redirect to cart" do
@@ -390,16 +399,17 @@ describe Spree::CheckoutController, :type => :controller do
       end
 
       it "should set flash message for no inventory" do
-        expect(flash[:error]).to eq(Spree.t(:inventory_error_flash_for_insufficient_quantity , :names => "'#{product.name}'" ))
+        expect(flash[:error]).to eq(
+          Spree.t(:inventory_error_flash_for_insufficient_quantity, names: "'#{product.name}'"))
       end
     end
   end
 
   context "order doesn't have a delivery step" do
     before do
-      allow(order).to receive_messages(:checkout_steps => ["cart", "address", "payment"])
+      allow(order).to receive_messages(checkout_steps: ["cart", "address", "payment"])
       allow(order).to receive_messages state: "address"
-      allow(controller).to receive_messages :check_authorization => true
+      allow(controller).to receive_messages check_authorization: true
     end
 
     it "doesn't set shipping address on the order" do
@@ -408,18 +418,16 @@ describe Spree::CheckoutController, :type => :controller do
     end
 
     it "doesn't remove unshippable items before payment" do
-      expect {
-        spree_post :update, { :state => "payment" }
-      }.to_not change { order.line_items }
+      expect { spree_post :update, state: "payment" }.
+        to_not change { order.line_items }
     end
   end
 
   it "does remove unshippable items before payment" do
-    allow(order).to receive_messages :payment_required? => true
-    allow(controller).to receive_messages :check_authorization => true
+    allow(order).to receive_messages payment_required?: true
+    allow(controller).to receive_messages check_authorization: true
 
-    expect {
-      spree_post :update, { :state => "payment" }
-    }.to change { order.reload.line_items.length }
+    expect { spree_post :update, state: "payment" }.
+      to change { order.reload.line_items.length }
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: spree_frontend
 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: spree_api
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.0.2
+        version: 3.0.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.0.2
+        version: 3.0.3
 - !ruby/object:Gem::Dependency
   name: spree_core
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.0.2
+        version: 3.0.3
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 3.0.2
+        version: 3.0.3
 - !ruby/object:Gem::Dependency
   name: bootstrap-sass
   requirement: !ruby/object:Gem::Requirement