Privatize unneededly protected methods in Active Record

Author: amatsuda

activerecord/lib/active_record/associations/collection_proxy.rb

@@ -1126,20 +1126,18 @@ def reset
         self
       end
 
-      protected
+      private
 
-        def find_nth_with_limit(index, limit)
+        def find_nth_with_limit(index, limit) # :doc:
           load_target if find_from_target?
           super
         end
 
-        def find_nth_from_last(index)
+        def find_nth_from_last(index) # :doc:
           load_target if find_from_target?
           super
         end
 
-      private
-
         def null_scope?
           @association.null_scope?
         end

activerecord/lib/active_record/associations/through_association.rb

@@ -4,13 +4,13 @@ module Associations
     module ThroughAssociation #:nodoc:
       delegate :source_reflection, :through_reflection, to: :reflection
 
-      protected
+      private
 
         # We merge in these scopes for two reasons:
         #
         #   1. To get the default_scope conditions for any of the other reflections in the chain
         #   2. To get the type conditions for any STI models in the chain
-        def target_scope
+        def target_scope # :doc:
           scope = super
           reflection.chain.drop(1).each do |reflection|
             relation = reflection.klass.all
@@ -21,8 +21,6 @@ def target_scope
           scope
         end
 
-      private
-
         # Construct attributes for :through pointing to owner and associate. This is used by the
         # methods which create and delete records on the association.
         #

activerecord/lib/active_record/attribute.rb

@@ -135,25 +135,26 @@ def encode_with(coder)
       attr_reader :original_attribute
       alias_method :assigned?, :original_attribute
 
-      def initialize_dup(other)
+      def original_value_for_database # :doc:
+        if assigned?
+          original_attribute.original_value_for_database
+        else
+          _original_value_for_database
+        end
+      end
+
+    private
+      def initialize_dup(other) # :doc:
         if defined?(@value) && @value.duplicable?
           @value = @value.dup
         end
       end
 
-      def changed_from_assignment?
+      def changed_from_assignment? # :doc:
         assigned? && type.changed?(original_value, value, value_before_type_cast)
       end
 
-      def original_value_for_database
-        if assigned?
-          original_attribute.original_value_for_database
-        else
-          _original_value_for_database
-        end
-      end
-
-      def _original_value_for_database
+      def _original_value_for_database # :doc:
         type.serialize(original_value)
       end
 

activerecord/lib/active_record/attribute_methods/primary_key.rb

@@ -50,9 +50,9 @@ def id_in_database
         attribute_in_database(self.class.primary_key)
       end
 
-      protected
+      private
 
-        def attribute_method?(attr_name)
+        def attribute_method?(attr_name) # :doc:
           attr_name == "id" || super
         end
 

activerecord/lib/active_record/attribute_methods/read.rb

@@ -4,7 +4,7 @@ module Read
       extend ActiveSupport::Concern
 
       module ClassMethods
-        protected
+        private
 
           # We want to generate the methods via module_eval rather than
           # define_method, because define_method is slower on dispatch.
@@ -24,7 +24,7 @@ module ClassMethods
           # to allocate an object on each call to the attribute method.
           # Making it frozen means that it doesn't get duped when used to
           # key the @attributes in read_attribute.
-          def define_method_attribute(name)
+          def define_method_attribute(name) # :doc:
             safe_name = name.unpack("h*".freeze).first
             temp_method = "__temp__#{safe_name}"
 

activerecord/lib/active_record/attribute_methods/write.rb

@@ -8,9 +8,9 @@ module Write
       end
 
       module ClassMethods
-        protected
+        private
 
-          def define_method_attribute=(name)
+          def define_method_attribute=(name) # :doc:
             safe_name = name.unpack("h*".freeze).first
             ActiveRecord::AttributeMethods::AttrNames.set_name_cache safe_name, name
 

activerecord/lib/active_record/connection_adapters/abstract/database_statements.rb

@@ -360,34 +360,34 @@ def join_to_update(update, select, key) # :nodoc:
       end
       alias join_to_delete join_to_update
 
-      protected
+      private
 
         # Returns a subquery for the given key using the join information.
-        def subquery_for(key, select)
+        def subquery_for(key, select) # :doc:
           subselect = select.clone
           subselect.projections = [key]
           subselect
         end
 
         # Returns an ActiveRecord::Result instance.
-        def select(sql, name = nil, binds = [])
+        def select(sql, name = nil, binds = []) # :doc:
           exec_query(sql, name, binds, prepare: false)
         end
 
-        def select_prepared(sql, name = nil, binds = [])
+        def select_prepared(sql, name = nil, binds = []) # :doc:
           exec_query(sql, name, binds, prepare: true)
         end
 
-        def sql_for_insert(sql, pk, id_value, sequence_name, binds)
+        def sql_for_insert(sql, pk, id_value, sequence_name, binds) # :doc:
           [sql, binds]
         end
 
-        def last_inserted_id(result)
+        def last_inserted_id(result) # :doc:
           row = result.rows.first
           row && row.first
         end
 
-        def binds_from_relation(relation, binds)
+        def binds_from_relation(relation, binds) # :doc:
           if relation.is_a?(Relation) && binds.empty?
             relation, binds = relation.arel, relation.bound_attributes
           end

activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb

@@ -1169,9 +1169,9 @@ def change_column_comment(table_name, column_name, comment) #:nodoc:
         raise NotImplementedError, "#{self.class} does not support changing column comments"
       end
 
-      protected
+      private
 
-        def add_index_sort_order(quoted_columns, **options)
+        def add_index_sort_order(quoted_columns, **options) # :doc:
           if order = options[:order]
             case order
             when Hash
@@ -1186,22 +1186,22 @@ def add_index_sort_order(quoted_columns, **options)
         end
 
         # Overridden by the MySQL adapter for supporting index lengths
-        def add_options_for_index_columns(quoted_columns, **options)
+        def add_options_for_index_columns(quoted_columns, **options) # :doc:
           if supports_index_sort_order?
             quoted_columns = add_index_sort_order(quoted_columns, options)
           end
 
           quoted_columns
         end
 
-        def quoted_columns_for_index(column_names, **options)
+        def quoted_columns_for_index(column_names, **options) # :doc:
           return [column_names] if column_names.is_a?(String)
 
           quoted_columns = Hash[column_names.map { |name| [name.to_sym, quote_column_name(name).dup] }]
           add_options_for_index_columns(quoted_columns, options).values
         end
 
-        def index_name_for_remove(table_name, options = {})
+        def index_name_for_remove(table_name, options = {}) # :doc:
           return options[:name] if can_remove_index_by_name?(options)
 
           checks = []
@@ -1231,7 +1231,7 @@ def index_name_for_remove(table_name, options = {})
           end
         end
 
-        def rename_table_indexes(table_name, new_name)
+        def rename_table_indexes(table_name, new_name) # :doc:
           indexes(new_name).each do |index|
             generated_index_name = index_name(table_name, column: index.columns)
             if generated_index_name == index.name
@@ -1240,7 +1240,7 @@ def rename_table_indexes(table_name, new_name)
           end
         end
 
-        def rename_column_indexes(table_name, column_name, new_column_name)
+        def rename_column_indexes(table_name, column_name, new_column_name) # :doc:
           column_name, new_column_name = column_name.to_s, new_column_name.to_s
           indexes(table_name).each do |index|
             next unless index.columns.include?(new_column_name)
@@ -1253,7 +1253,6 @@ def rename_column_indexes(table_name, column_name, new_column_name)
           end
         end
 
-      private
         def create_table_definition(*args)
           TableDefinition.new(*args)
         end

activerecord/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -499,9 +499,9 @@ def combine_bind_parameters(
         result
       end
 
-      protected
+      private
 
-        def initialize_type_map(m) # :nodoc:
+        def initialize_type_map(m)
           register_class_with_limit m, %r(boolean)i,       Type::Boolean
           register_class_with_limit m, %r(char)i,          Type::String
           register_class_with_limit m, %r(binary)i,        Type::Binary
@@ -532,37 +532,37 @@ def initialize_type_map(m) # :nodoc:
           end
         end
 
-        def reload_type_map # :nodoc:
+        def reload_type_map
           type_map.clear
           initialize_type_map(type_map)
         end
 
-        def register_class_with_limit(mapping, key, klass) # :nodoc:
+        def register_class_with_limit(mapping, key, klass)
           mapping.register_type(key) do |*args|
             limit = extract_limit(args.last)
             klass.new(limit: limit)
           end
         end
 
-        def register_class_with_precision(mapping, key, klass) # :nodoc:
+        def register_class_with_precision(mapping, key, klass)
           mapping.register_type(key) do |*args|
             precision = extract_precision(args.last)
             klass.new(precision: precision)
           end
         end
 
-        def extract_scale(sql_type) # :nodoc:
+        def extract_scale(sql_type)
           case sql_type
           when /\((\d+)\)/ then 0
           when /\((\d+)(,(\d+))\)/ then $3.to_i
           end
         end
 
-        def extract_precision(sql_type) # :nodoc:
+        def extract_precision(sql_type)
           $1.to_i if sql_type =~ /\((\d+)(,\d+)?\)/
         end
 
-        def extract_limit(sql_type) # :nodoc:
+        def extract_limit(sql_type)
           case sql_type
           when /^bigint/i
             8
@@ -571,7 +571,7 @@ def extract_limit(sql_type) # :nodoc:
           end
         end
 
-        def translate_exception_class(e, sql)
+        def translate_exception_class(e, sql) # :doc:
           begin
             message = "#{e.class.name}: #{e.message}: #{sql}"
           rescue Encoding::CompatibilityError
@@ -583,7 +583,7 @@ def translate_exception_class(e, sql)
           exception
         end
 
-        def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil)
+        def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name = nil) # :doc:
           @instrumenter.instrument(
             "sql.active_record",
             sql:               sql,
@@ -596,7 +596,7 @@ def log(sql, name = "SQL", binds = [], type_casted_binds = [], statement_name =
           raise translate_exception_class(e, sql)
         end
 
-        def translate_exception(exception, message)
+        def translate_exception(exception, message) # :doc:
           # override in derived class
           case exception
           when RuntimeError
@@ -606,11 +606,11 @@ def translate_exception(exception, message)
           end
         end
 
-        def without_prepared_statement?(binds)
+        def without_prepared_statement?(binds) # :doc:
           !prepared_statements || binds.empty?
         end
 
-        def column_for(table_name, column_name) # :nodoc:
+        def column_for(table_name, column_name)
           column_name = column_name.to_s
           columns(table_name).detect { |c| c.name == column_name } ||
             raise(ActiveRecordError, "No such column: #{table_name}.#{column_name}")