normalizes indentation and whitespace across the project

5 files changed, 238 insertions, 238 deletions

diff --git a/actionpack/lib/action_dispatch/routing/inspector.rb b/actionpack/lib/action_dispatch/routing/inspector.rb
index a66a1d4ca4..b91ffb8419 100644
--- a/actionpack/lib/action_dispatch/routing/inspector.rb
+++ b/actionpack/lib/action_dispatch/routing/inspector.rb
@@ -80,48 +80,48 @@ module ActionDispatch
 
       private
 
-      def normalize_filter(filter)
-        if filter.is_a?(Hash) && filter[:controller]
-          { controller: /#{filter[:controller].downcase.sub(/_?controller\z/, '').sub('::', '/')}/ }
-        elsif filter
-          { controller: /#{filter}/, action: /#{filter}/, verb: /#{filter}/, name: /#{filter}/, path: /#{filter}/ }
+        def normalize_filter(filter)
+          if filter.is_a?(Hash) && filter[:controller]
+            { controller: /#{filter[:controller].downcase.sub(/_?controller\z/, '').sub('::', '/')}/ }
+          elsif filter
+            { controller: /#{filter}/, action: /#{filter}/, verb: /#{filter}/, name: /#{filter}/, path: /#{filter}/ }
+          end
         end
-      end
 
-      def filter_routes(filter)
-        if filter
-          @routes.select do |route|
-            route_wrapper = RouteWrapper.new(route)
-            filter.any? { |default, value| route_wrapper.send(default) =~ value }
+        def filter_routes(filter)
+          if filter
+            @routes.select do |route|
+              route_wrapper = RouteWrapper.new(route)
+              filter.any? { |default, value| route_wrapper.send(default) =~ value }
+            end
+          else
+            @routes
           end
-        else
-          @routes
         end
-      end
 
-      def collect_routes(routes)
-        routes.collect do |route|
-          RouteWrapper.new(route)
-        end.reject(&:internal?).collect do |route|
-          collect_engine_routes(route)
+        def collect_routes(routes)
+          routes.collect do |route|
+            RouteWrapper.new(route)
+          end.reject(&:internal?).collect do |route|
+            collect_engine_routes(route)
 
-          { name: route.name,
-            verb: route.verb,
-            path: route.path,
-            reqs: route.reqs }
+            { name: route.name,
+              verb: route.verb,
+              path: route.path,
+              reqs: route.reqs }
+          end
         end
-      end
 
-      def collect_engine_routes(route)
-        name = route.endpoint
-        return unless route.engine?
-        return if @engines[name]
+        def collect_engine_routes(route)
+          name = route.endpoint
+          return unless route.engine?
+          return if @engines[name]
 
-        routes = route.rack_app.routes
-        if routes.is_a?(ActionDispatch::Routing::RouteSet)
-          @engines[name] = collect_routes(routes.routes)
+          routes = route.rack_app.routes
+          if routes.is_a?(ActionDispatch::Routing::RouteSet)
+            @engines[name] = collect_routes(routes.routes)
+          end
         end
-      end
     end
 
     class ConsoleFormatter
diff --git a/actionpack/lib/action_dispatch/routing/mapper.rb b/actionpack/lib/action_dispatch/routing/mapper.rb
index 7034f25b09..a6b177480d 100644
--- a/actionpack/lib/action_dispatch/routing/mapper.rb
+++ b/actionpack/lib/action_dispatch/routing/mapper.rb
@@ -1684,7 +1684,7 @@ to this:
           end
 
           as = if !options.fetch(:as, true) # if it's set to nil or false
-                 options.delete(:as)
+            options.delete(:as)
                else
                  name_for_action(options.delete(:as), action)
                end
@@ -1914,24 +1914,24 @@ to this:
           end
         private
 
-        def path_scope(path)
-          @scope = @scope.new(path: merge_path_scope(@scope[:path], path))
-          yield
-        ensure
-          @scope = @scope.parent
-        end
+          def path_scope(path)
+            @scope = @scope.new(path: merge_path_scope(@scope[:path], path))
+            yield
+          ensure
+            @scope = @scope.parent
+          end
 
-        def match_root_route(options)
-          name = has_named_route?(:root) ? nil : :root
-          defaults_option = options.delete(:defaults)
-          args = ["/", { as: name, via: :get }.merge!(options)]
+          def match_root_route(options)
+            name = has_named_route?(:root) ? nil : :root
+            defaults_option = options.delete(:defaults)
+            args = ["/", { as: name, via: :get }.merge!(options)]
 
-          if defaults_option
-            defaults(defaults_option) { match(*args) }
-          else
-            match(*args)
+            if defaults_option
+              defaults(defaults_option) { match(*args) }
+            else
+              match(*args)
+            end
           end
-        end
       end
 
       # Routing Concerns allow you to declare common routes that can be reused
diff --git a/actionpack/lib/action_dispatch/routing/polymorphic_routes.rb b/actionpack/lib/action_dispatch/routing/polymorphic_routes.rb
index a0874d6be3..3e2b21ac72 100644
--- a/actionpack/lib/action_dispatch/routing/polymorphic_routes.rb
+++ b/actionpack/lib/action_dispatch/routing/polymorphic_routes.rb
@@ -149,176 +149,176 @@ module ActionDispatch
 
       private
 
-      def polymorphic_url_for_action(action, record_or_hash, options)
-        polymorphic_url(record_or_hash, options.merge(action: action))
-      end
+        def polymorphic_url_for_action(action, record_or_hash, options)
+          polymorphic_url(record_or_hash, options.merge(action: action))
+        end
 
-      def polymorphic_path_for_action(action, record_or_hash, options)
-        polymorphic_path(record_or_hash, options.merge(action: action))
-      end
+        def polymorphic_path_for_action(action, record_or_hash, options)
+          polymorphic_path(record_or_hash, options.merge(action: action))
+        end
 
-      class HelperMethodBuilder # :nodoc:
-        CACHE = { "path" => {}, "url" => {} }
+        class HelperMethodBuilder # :nodoc:
+          CACHE = { "path" => {}, "url" => {} }
 
-        def self.get(action, type)
-          type   = type.to_s
-          CACHE[type].fetch(action) { build action, type }
-        end
+          def self.get(action, type)
+            type   = type.to_s
+            CACHE[type].fetch(action) { build action, type }
+          end
 
-        def self.url;  CACHE["url".freeze][nil]; end
-        def self.path; CACHE["path".freeze][nil]; end
+          def self.url;  CACHE["url".freeze][nil]; end
+          def self.path; CACHE["path".freeze][nil]; end
 
-        def self.build(action, type)
-          prefix = action ? "#{action}_" : ""
-          suffix = type
-          if action.to_s == "new"
-            HelperMethodBuilder.singular prefix, suffix
-          else
-            HelperMethodBuilder.plural prefix, suffix
+          def self.build(action, type)
+            prefix = action ? "#{action}_" : ""
+            suffix = type
+            if action.to_s == "new"
+              HelperMethodBuilder.singular prefix, suffix
+            else
+              HelperMethodBuilder.plural prefix, suffix
+            end
           end
-        end
 
-        def self.singular(prefix, suffix)
-          new(->(name) { name.singular_route_key }, prefix, suffix)
-        end
+          def self.singular(prefix, suffix)
+            new(->(name) { name.singular_route_key }, prefix, suffix)
+          end
 
-        def self.plural(prefix, suffix)
-          new(->(name) { name.route_key }, prefix, suffix)
-        end
+          def self.plural(prefix, suffix)
+            new(->(name) { name.route_key }, prefix, suffix)
+          end
 
-        def self.polymorphic_method(recipient, record_or_hash_or_array, action, type, options)
-          builder = get action, type
+          def self.polymorphic_method(recipient, record_or_hash_or_array, action, type, options)
+            builder = get action, type
+
+            case record_or_hash_or_array
+            when Array
+              record_or_hash_or_array = record_or_hash_or_array.compact
+              if record_or_hash_or_array.empty?
+                raise ArgumentError, "Nil location provided. Can't build URI."
+              end
+              if record_or_hash_or_array.first.is_a?(ActionDispatch::Routing::RoutesProxy)
+                recipient = record_or_hash_or_array.shift
+              end
+
+              method, args = builder.handle_list record_or_hash_or_array
+            when String, Symbol
+              method, args = builder.handle_string record_or_hash_or_array
+            when Class
+              method, args = builder.handle_class record_or_hash_or_array
 
-          case record_or_hash_or_array
-          when Array
-            record_or_hash_or_array = record_or_hash_or_array.compact
-            if record_or_hash_or_array.empty?
+            when nil
               raise ArgumentError, "Nil location provided. Can't build URI."
-            end
-            if record_or_hash_or_array.first.is_a?(ActionDispatch::Routing::RoutesProxy)
-              recipient = record_or_hash_or_array.shift
+            else
+              method, args = builder.handle_model record_or_hash_or_array
             end
 
-            method, args = builder.handle_list record_or_hash_or_array
-          when String, Symbol
-            method, args = builder.handle_string record_or_hash_or_array
-          when Class
-            method, args = builder.handle_class record_or_hash_or_array
 
-          when nil
-            raise ArgumentError, "Nil location provided. Can't build URI."
-          else
-            method, args = builder.handle_model record_or_hash_or_array
+            if options.empty?
+              recipient.send(method, *args)
+            else
+              recipient.send(method, *args, options)
+            end
           end
 
+          attr_reader :suffix, :prefix
 
-          if options.empty?
-            recipient.send(method, *args)
-          else
-            recipient.send(method, *args, options)
+          def initialize(key_strategy, prefix, suffix)
+            @key_strategy = key_strategy
+            @prefix       = prefix
+            @suffix       = suffix
           end
-        end
-
-        attr_reader :suffix, :prefix
-
-        def initialize(key_strategy, prefix, suffix)
-          @key_strategy = key_strategy
-          @prefix       = prefix
-          @suffix       = suffix
-        end
-
-        def handle_string(record)
-          [get_method_for_string(record), []]
-        end
-
-        def handle_string_call(target, str)
-          target.send get_method_for_string str
-        end
 
-        def handle_class(klass)
-          [get_method_for_class(klass), []]
-        end
+          def handle_string(record)
+            [get_method_for_string(record), []]
+          end
 
-        def handle_class_call(target, klass)
-          target.send get_method_for_class klass
-        end
+          def handle_string_call(target, str)
+            target.send get_method_for_string str
+          end
 
-        def handle_model(record)
-          args  = []
+          def handle_class(klass)
+            [get_method_for_class(klass), []]
+          end
 
-          model = record.to_model
-          named_route = if model.persisted?
-                          args << model
-                          get_method_for_string model.model_name.singular_route_key
-                        else
-                          get_method_for_class model
-                        end
+          def handle_class_call(target, klass)
+            target.send get_method_for_class klass
+          end
 
-          [named_route, args]
-        end
+          def handle_model(record)
+            args  = []
 
-        def handle_model_call(target, model)
-          method, args = handle_model model
-          target.send(method, *args)
-        end
+            model = record.to_model
+            named_route = if model.persisted?
+              args << model
+              get_method_for_string model.model_name.singular_route_key
+                          else
+                            get_method_for_class model
+                          end
 
-        def handle_list(list)
-          record_list = list.dup
-          record      = record_list.pop
+            [named_route, args]
+          end
 
-          args = []
+          def handle_model_call(target, model)
+            method, args = handle_model model
+            target.send(method, *args)
+          end
 
-          route  = record_list.map { |parent|
-            case parent
+          def handle_list(list)
+            record_list = list.dup
+            record      = record_list.pop
+
+            args = []
+
+            route  = record_list.map { |parent|
+              case parent
+              when Symbol, String
+                parent.to_s
+              when Class
+                args << parent
+                parent.model_name.singular_route_key
+              else
+                args << parent.to_model
+                parent.to_model.model_name.singular_route_key
+              end
+            }
+
+            route <<
+            case record
             when Symbol, String
-              parent.to_s
+              record.to_s
             when Class
-              args << parent
-              parent.model_name.singular_route_key
+              @key_strategy.call record.model_name
             else
-              args << parent.to_model
-              parent.to_model.model_name.singular_route_key
+              model = record.to_model
+              if model.persisted?
+                args << model
+                model.model_name.singular_route_key
+              else
+                @key_strategy.call model.model_name
+              end
             end
-          }
-
-          route <<
-          case record
-          when Symbol, String
-            record.to_s
-          when Class
-            @key_strategy.call record.model_name
-          else
-            model = record.to_model
-            if model.persisted?
-              args << model
-              model.model_name.singular_route_key
-            else
-              @key_strategy.call model.model_name
-            end
-          end
 
-          route << suffix
+            route << suffix
 
-          named_route = prefix + route.join("_")
-          [named_route, args]
-        end
+            named_route = prefix + route.join("_")
+            [named_route, args]
+          end
 
-        private
+          private
 
-        def get_method_for_class(klass)
-          name   = @key_strategy.call klass.model_name
-          get_method_for_string name
-        end
+            def get_method_for_class(klass)
+              name   = @key_strategy.call klass.model_name
+              get_method_for_string name
+            end
 
-        def get_method_for_string(str)
-          "#{prefix}#{str}_#{suffix}"
-        end
+            def get_method_for_string(str)
+              "#{prefix}#{str}_#{suffix}"
+            end
 
-        [nil, "new", "edit"].each do |action|
-          CACHE["url"][action]  = build action, "url"
-          CACHE["path"][action] = build action, "path"
+            [nil, "new", "edit"].each do |action|
+              CACHE["url"][action]  = build action, "url"
+              CACHE["path"][action] = build action, "path"
+            end
         end
-      end
     end
   end
 end
diff --git a/actionpack/lib/action_dispatch/routing/route_set.rb b/actionpack/lib/action_dispatch/routing/route_set.rb
index c1ea23e36d..b9eda039a1 100644
--- a/actionpack/lib/action_dispatch/routing/route_set.rb
+++ b/actionpack/lib/action_dispatch/routing/route_set.rb
@@ -59,7 +59,7 @@ module ActionDispatch
 
         private
 
-        def controller(_); @controller_class; end
+          def controller(_); @controller_class; end
       end
 
       # A NamedRouteCollection instance is a collection of named routes, and also
@@ -180,40 +180,40 @@ module ActionDispatch
 
             private
 
-            def optimized_helper(args)
-              params = parameterize_args(args) do
-                raise_generation_error(args)
-              end
+              def optimized_helper(args)
+                params = parameterize_args(args) do
+                  raise_generation_error(args)
+                end
 
-              @route.format params
-            end
+                @route.format params
+              end
 
-            def optimize_routes_generation?(t)
-              t.send(:optimize_routes_generation?)
-            end
+              def optimize_routes_generation?(t)
+                t.send(:optimize_routes_generation?)
+              end
 
-            def parameterize_args(args)
-              params = {}
-              @arg_size.times { |i|
-                key = @required_parts[i]
-                value = args[i].to_param
-                yield key if value.nil? || value.empty?
-                params[key] = value
-              }
-              params
-            end
+              def parameterize_args(args)
+                params = {}
+                @arg_size.times { |i|
+                  key = @required_parts[i]
+                  value = args[i].to_param
+                  yield key if value.nil? || value.empty?
+                  params[key] = value
+                }
+                params
+              end
 
-            def raise_generation_error(args)
-              missing_keys = []
-              params = parameterize_args(args) { |missing_key|
-                missing_keys << missing_key
-              }
-              constraints = Hash[@route.requirements.merge(params).sort_by{|k,v| k.to_s}]
-              message = "No route matches #{constraints.inspect}"
-              message << " missing required keys: #{missing_keys.sort.inspect}"
+              def raise_generation_error(args)
+                missing_keys = []
+                params = parameterize_args(args) { |missing_key|
+                  missing_keys << missing_key
+                }
+                constraints = Hash[@route.requirements.merge(params).sort_by{|k,v| k.to_s}]
+                message = "No route matches #{constraints.inspect}"
+                message << " missing required keys: #{missing_keys.sort.inspect}"
 
-              raise ActionController::UrlGenerationError, message
-            end
+                raise ActionController::UrlGenerationError, message
+              end
           end
 
           def initialize(route, options, route_name, url_strategy)
@@ -277,25 +277,25 @@ module ActionDispatch
         #
         #   foo_url(bar, baz, bang, sort_by: 'baz')
         #
-        def define_url_helper(mod, route, name, opts, route_key, url_strategy)
-          helper = UrlHelper.create(route, opts, route_key, url_strategy)
-          mod.module_eval do
-            define_method(name) do |*args|
-              last = args.last
-              options = case last
-                        when Hash
-                          args.pop
-                        when ActionController::Parameters
-                          if last.permitted?
-                            args.pop.to_h
-                          else
-                            raise ArgumentError, ActionDispatch::Routing::INSECURE_URL_PARAMETERS_MESSAGE
+          def define_url_helper(mod, route, name, opts, route_key, url_strategy)
+            helper = UrlHelper.create(route, opts, route_key, url_strategy)
+            mod.module_eval do
+              define_method(name) do |*args|
+                last = args.last
+                options = case last
+                          when Hash
+                            args.pop
+                          when ActionController::Parameters
+                            if last.permitted?
+                              args.pop.to_h
+                            else
+                              raise ArgumentError, ActionDispatch::Routing::INSECURE_URL_PARAMETERS_MESSAGE
+                            end
                           end
-                        end
-              helper.call self, args, options
+                helper.call self, args, options
+              end
             end
           end
-        end
       end
 
       # strategy for building urls to send to the client
diff --git a/actionpack/lib/action_dispatch/routing/url_for.rb b/actionpack/lib/action_dispatch/routing/url_for.rb
index 5ee138e6c6..a1ac5a2b6c 100644
--- a/actionpack/lib/action_dispatch/routing/url_for.rb
+++ b/actionpack/lib/action_dispatch/routing/url_for.rb
@@ -194,20 +194,20 @@ module ActionDispatch
 
       protected
 
-      def optimize_routes_generation?
-        _routes.optimize_routes_generation? && default_url_options.empty?
-      end
+        def optimize_routes_generation?
+          _routes.optimize_routes_generation? && default_url_options.empty?
+        end
 
-      def _with_routes(routes)
-        old_routes, @_routes = @_routes, routes
-        yield
-      ensure
-        @_routes = old_routes
-      end
+        def _with_routes(routes)
+          old_routes, @_routes = @_routes, routes
+          yield
+        ensure
+          @_routes = old_routes
+        end
 
-      def _routes_context
-        self
-      end
+        def _routes_context
+          self
+        end
     end
   end
 end