normalizes indentation and whitespace across the project

1 files changed, 43 insertions, 43 deletions

diff --git a/activesupport/lib/active_support/file_update_checker.rb b/activesupport/lib/active_support/file_update_checker.rb
index 6befd1de51..0b7d67e37a 100644
--- a/activesupport/lib/active_support/file_update_checker.rb
+++ b/activesupport/lib/active_support/file_update_checker.rb
@@ -93,17 +93,17 @@ module ActiveSupport
 
     private
 
-    def watched
-      @watched || begin
-        all = @files.select { |f| File.exist?(f) }
-        all.concat(Dir[@glob]) if @glob
-        all
+      def watched
+        @watched || begin
+          all = @files.select { |f| File.exist?(f) }
+          all.concat(Dir[@glob]) if @glob
+          all
+        end
       end
-    end
 
-    def updated_at(paths)
-      @updated_at || max_mtime(paths) || Time.at(0)
-    end
+      def updated_at(paths)
+        @updated_at || max_mtime(paths) || Time.at(0)
+      end
 
     # This method returns the maximum mtime of the files in +paths+, or +nil+
     # if the array is empty.
@@ -112,46 +112,46 @@ module ActiveSupport
     # can happen for example if the user changes the clock by hand. It is
     # healthy to consider this edge case because with mtimes in the future
     # reloading is not triggered.
-    def max_mtime(paths)
-      time_now = Time.now
-      max_mtime = nil
-
-      # Time comparisons are performed with #compare_without_coercion because
-      # AS redefines these operators in a way that is much slower and does not
-      # bring any benefit in this particular code.
-      #
-      # Read t1.compare_without_coercion(t2) < 0 as t1 < t2.
-      paths.each do |path|
-        mtime = File.mtime(path)
-
-        next if time_now.compare_without_coercion(mtime) < 0
-
-        if max_mtime.nil? || max_mtime.compare_without_coercion(mtime) < 0
-          max_mtime = mtime
+      def max_mtime(paths)
+        time_now = Time.now
+        max_mtime = nil
+
+        # Time comparisons are performed with #compare_without_coercion because
+        # AS redefines these operators in a way that is much slower and does not
+        # bring any benefit in this particular code.
+        #
+        # Read t1.compare_without_coercion(t2) < 0 as t1 < t2.
+        paths.each do |path|
+          mtime = File.mtime(path)
+
+          next if time_now.compare_without_coercion(mtime) < 0
+
+          if max_mtime.nil? || max_mtime.compare_without_coercion(mtime) < 0
+            max_mtime = mtime
+          end
         end
-      end
 
-      max_mtime
-    end
+        max_mtime
+      end
 
-    def compile_glob(hash)
-      hash.freeze # Freeze so changes aren't accidentally pushed
-      return if hash.empty?
+      def compile_glob(hash)
+        hash.freeze # Freeze so changes aren't accidentally pushed
+        return if hash.empty?
 
-      globs = hash.map do |key, value|
-        "#{escape(key)}/**/*#{compile_ext(value)}"
+        globs = hash.map do |key, value|
+          "#{escape(key)}/**/*#{compile_ext(value)}"
+        end
+        "{#{globs.join(",")}}"
       end
-      "{#{globs.join(",")}}"
-    end
 
-    def escape(key)
-      key.gsub(",",'\,')
-    end
+      def escape(key)
+        key.gsub(",",'\,')
+      end
 
-    def compile_ext(array)
-      array = Array(array)
-      return if array.empty?
-      ".{#{array.join(",")}}"
-    end
+      def compile_ext(array)
+        array = Array(array)
+        return if array.empty?
+        ".{#{array.join(",")}}"
+      end
   end
 end