Privatize unneededly protected methods in Active Support

Author: amatsuda

activesupport/lib/active_support/cache.rb

@@ -471,12 +471,12 @@ def clear
         raise NotImplementedError.new("#{self.class.name} does not support clear")
       end
 
-      protected
+      private
         # Adds the namespace defined in the options to a pattern designed to
         # match keys. Implementations that support delete_matched should call
         # this method to translate a pattern that matches names into one that
         # matches namespaced keys.
-        def key_matcher(pattern, options)
+        def key_matcher(pattern, options) # :doc:
           prefix = options[:namespace].is_a?(Proc) ? options[:namespace].call : options[:namespace]
           if prefix
             source = pattern.source
@@ -493,23 +493,22 @@ def key_matcher(pattern, options)
 
         # Reads an entry from the cache implementation. Subclasses must implement
         # this method.
-        def read_entry(key, options) # :nodoc:
+        def read_entry(key, options)
           raise NotImplementedError.new
         end
 
         # Writes an entry to the cache implementation. Subclasses must implement
         # this method.
-        def write_entry(key, entry, options) # :nodoc:
+        def write_entry(key, entry, options)
           raise NotImplementedError.new
         end
 
         # Deletes an entry from the cache implementation. Subclasses must
         # implement this method.
-        def delete_entry(key, options) # :nodoc:
+        def delete_entry(key, options)
           raise NotImplementedError.new
         end
 
-      private
         # Merges the default options with ones specific to a method call.
         def merged_options(call_options)
           if call_options

activesupport/lib/active_support/cache/file_store.rb

@@ -66,7 +66,7 @@ def delete_matched(matcher, options = nil)
         end
       end
 
-      protected
+      private
 
         def read_entry(key, options)
           if File.exist?(key)
@@ -98,7 +98,6 @@ def delete_entry(key, options)
           end
         end
 
-      private
         # Lock a file for a block so only one process can modify it at a time.
         def lock_file(file_name, &block)
           if File.exist?(file_name)

activesupport/lib/active_support/cache/mem_cache_store.rb

@@ -26,7 +26,7 @@ module Cache
     class MemCacheStore < Store
       # Provide support for raw values in the local cache strategy.
       module LocalCacheWithRaw # :nodoc:
-        protected
+        private
           def read_entry(key, options)
             entry = super
             if options[:raw] && local_cache && entry
@@ -35,7 +35,7 @@ def read_entry(key, options)
             entry
           end
 
-          def write_entry(key, entry, options) # :nodoc:
+          def write_entry(key, entry, options)
             if options[:raw] && local_cache
               raw_entry = Entry.new(entry.value.to_s)
               raw_entry.expires_at = entry.expires_at
@@ -143,14 +143,14 @@ def stats
         @data.stats
       end
 
-      protected
+      private
         # Read an entry from the cache.
-        def read_entry(key, options) # :nodoc:
+        def read_entry(key, options)
           rescue_error_with(nil) { deserialize_entry(@data.get(key, options)) }
         end
 
         # Write an entry to the cache.
-        def write_entry(key, entry, options) # :nodoc:
+        def write_entry(key, entry, options)
           method = options && options[:unless_exist] ? :add : :set
           value = options[:raw] ? entry.value.to_s : entry
           expires_in = options[:expires_in].to_i
@@ -164,12 +164,10 @@ def write_entry(key, entry, options) # :nodoc:
         end
 
         # Delete an entry from the cache.
-        def delete_entry(key, options) # :nodoc:
+        def delete_entry(key, options)
           rescue_error_with(false) { @data.delete(key) }
         end
 
-      private
-
         # Memcache keys are binaries. So we need to force their encoding to binary
         # before applying the regular expression to ensure we are escaping all
         # characters properly.

activesupport/lib/active_support/cache/memory_store.rb

@@ -104,15 +104,15 @@ def synchronize(&block) # :nodoc:
         @monitor.synchronize(&block)
       end
 
-      protected
+      private
 
         PER_ENTRY_OVERHEAD = 240
 
-        def cached_size(key, entry) # :nodoc:
+        def cached_size(key, entry)
           key.to_s.bytesize + entry.size + PER_ENTRY_OVERHEAD
         end
 
-        def read_entry(key, options) # :nodoc:
+        def read_entry(key, options)
           entry = @data[key]
           synchronize do
             if entry
@@ -124,7 +124,7 @@ def read_entry(key, options) # :nodoc:
           entry
         end
 
-        def write_entry(key, entry, options) # :nodoc:
+        def write_entry(key, entry, options)
           entry.dup_value!
           synchronize do
             old_entry = @data[key]
@@ -141,7 +141,7 @@ def write_entry(key, entry, options) # :nodoc:
           end
         end
 
-        def delete_entry(key, options) # :nodoc:
+        def delete_entry(key, options)
           synchronize do
             @key_access.delete(key)
             entry = @data.delete(key)
@@ -150,8 +150,6 @@ def delete_entry(key, options) # :nodoc:
           end
         end
 
-      private
-
         def modify_value(name, amount, options)
           synchronize do
             options = merged_options(options)

activesupport/lib/active_support/cache/null_store.rb

@@ -25,15 +25,15 @@ def decrement(name, amount = 1, options = nil)
       def delete_matched(matcher, options = nil)
       end
 
-      protected
-        def read_entry(key, options) # :nodoc:
+      private
+        def read_entry(key, options)
         end
 
-        def write_entry(key, entry, options) # :nodoc:
+        def write_entry(key, entry, options)
           true
         end
 
-        def delete_entry(key, options) # :nodoc:
+        def delete_entry(key, options)
           false
         end
     end

activesupport/lib/active_support/cache/strategy/local_cache.rb

@@ -105,26 +105,26 @@ def decrement(name, amount = 1, options = nil) # :nodoc:
           value
         end
 
-        protected
-          def read_entry(key, options) # :nodoc:
+        private
+          def read_entry(key, options)
             if cache = local_cache
               cache.fetch_entry(key) { super }
             else
               super
             end
           end
 
-          def write_entry(key, entry, options) # :nodoc:
+          def write_entry(key, entry, options)
             local_cache.write_entry(key, entry, options) if local_cache
             super
           end
 
-          def delete_entry(key, options) # :nodoc:
+          def delete_entry(key, options)
             local_cache.delete_entry(key, options) if local_cache
             super
           end
 
-          def write_cache_value(name, value, options) # :nodoc:
+          def write_cache_value(name, value, options)
             name = normalize_key(name, options)
             cache = local_cache
             cache.mute do
@@ -136,8 +136,6 @@ def write_cache_value(name, value, options) # :nodoc:
             end
           end
 
-        private
-
           def local_cache_key
             @local_cache_key ||= "#{self.class.name.underscore}_local_cache_#{object_id}".gsub(/[\/-]/, "_").to_sym
           end

activesupport/lib/active_support/duration.rb

@@ -159,9 +159,9 @@ def iso8601(precision: nil)
 
     delegate :<=>, to: :value
 
-    protected
+    private
 
-      def sum(sign, time = ::Time.current) #:nodoc:
+      def sum(sign, time = ::Time.current)
         parts.inject(time) do |t, (type, number)|
           if t.acts_like?(:time) || t.acts_like?(:date)
             if type == :seconds
@@ -179,8 +179,6 @@ def sum(sign, time = ::Time.current) #:nodoc:
         end
       end
 
-    private
-
       def method_missing(method, *args, &block)
         value.send(method, *args, &block)
       end

activesupport/lib/active_support/hash_with_indifferent_access.rb

@@ -280,12 +280,12 @@ def to_hash
       _new_hash
     end
 
-    protected
-      def convert_key(key)
+    private
+      def convert_key(key) # :doc:
         key.kind_of?(Symbol) ? key.to_s : key
       end
 
-      def convert_value(value, options = {})
+      def convert_value(value, options = {}) # :doc:
         if value.is_a? Hash
           if options[:for] == :to_hash
             value.to_hash
@@ -302,7 +302,7 @@ def convert_value(value, options = {})
         end
       end
 
-      def set_defaults(target)
+      def set_defaults(target) # :doc:
         if default_proc
           target.default_proc = default_proc.dup
         else

activesupport/lib/active_support/inflector/methods.rb

@@ -361,7 +361,7 @@ def ordinalize(number)
       #
       #   const_regexp("Foo::Bar::Baz") # => "Foo(::Bar(::Baz)?)?"
       #   const_regexp("::")            # => "::"
-      def const_regexp(camel_cased_word) #:nodoc:
+      def const_regexp(camel_cased_word)
         parts = camel_cased_word.split("::".freeze)
 
         return Regexp.escape(camel_cased_word) if parts.blank?

activesupport/lib/active_support/log_subscriber.rb

@@ -85,7 +85,7 @@ def finish(name, id, payload)
       logger.error "Could not log #{name.inspect} event. #{e.class}: #{e.message} #{e.backtrace}"
     end
 
-  protected
+  private
 
     %w(info debug warn error fatal unknown).each do |level|
       class_eval <<-METHOD, __FILE__, __LINE__ + 1
@@ -99,7 +99,7 @@ def #{level}(progname = nil, &block)
     # option is set to +true+, it also adds bold to the string. This is based
     # on the Highline implementation and will automatically append CLEAR to the
     # end of the returned String.
-    def color(text, color, bold = false)
+    def color(text, color, bold = false) # :doc:
       return text unless colorize_logging
       color = self.class.const_get(color.upcase) if color.is_a?(Symbol)
       bold  = bold ? BOLD : ""