Bump RuboCop to latest and autocorrect offenses

Remove version pin on rubocop gem. Update .rubocop.yml for renamed
cops (Layout/Tab -> Layout/IndentationStyle) and target Ruby 3.2.
Autocorrect all 66 Layout/LeadingCommentSpace and
Layout/SpaceAroundOperators offenses.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: yahonda

.rubocop.yml

@@ -1,9 +1,7 @@
-# rubocop 0.51.0 requires Ruby 2.1
-# We should not use cops only available for Ruby 2.1 or later
-# since ruby-plsql itself supports Ruby 1.9.3
 AllCops:
-  TargetRubyVersion: 2.3
+  TargetRubyVersion: 3.2
   DisabledByDefault: true
+  NewCops: disable
 
 # Prefer &&/|| over and/or.
 Style/AndOr:
@@ -112,7 +110,7 @@ Style/StringLiterals:
   EnforcedStyle: double_quotes
 
 # Detect hard tabs, no hard tabs.
-Layout/Tab:
+Layout/IndentationStyle:
   Enabled: true
 
 # Blank lines should not have any spaces.
@@ -132,7 +130,6 @@ Style/RedundantPercentQ:
 Layout/EndAlignment:
   Enabled: true
   EnforcedStyleAlignWith: variable
-  AutoCorrect: true
 
 # Use my_method(my_arg) not my_method( my_arg ) or my_method my_arg.
 Lint/RequireParentheses:

Gemfile

@@ -3,7 +3,7 @@ source "http://rubygems.org"
 group :development do
   gem "juwelier", "~> 2.0"
   gem "rspec_junit_formatter"
-  gem "rubocop", "0.81", require: false
+  gem "rubocop", require: false
   gem "rubocop-performance", require: false
   gem "rubocop-rails", require: false
 end

lib/plsql/connection.rb

@@ -3,13 +3,13 @@ class Connection
     attr_reader :raw_driver
     attr_reader :activerecord_class
 
-    def initialize(raw_conn, ar_class = nil) #:nodoc:
+    def initialize(raw_conn, ar_class = nil) # :nodoc:
       @raw_driver = self.class.driver_type
       @raw_connection = raw_conn
       @activerecord_class = ar_class
     end
 
-    def self.create(raw_conn, ar_class = nil) #:nodoc:
+    def self.create(raw_conn, ar_class = nil) # :nodoc:
       if ar_class && !(defined?(::ActiveRecord) && ar_class.ancestors.include?(::ActiveRecord::Base))
         raise ArgumentError, "Wrong ActiveRecord class"
       end
@@ -23,7 +23,7 @@ def self.create(raw_conn, ar_class = nil) #:nodoc:
       end
     end
 
-    def self.create_new(params) #:nodoc:
+    def self.create_new(params) # :nodoc:
       conn = case driver_type
              when :oci
                OCIConnection.create_raw(params)
@@ -36,7 +36,7 @@ def self.create_new(params) #:nodoc:
       conn
     end
 
-    def self.driver_type #:nodoc:
+    def self.driver_type # :nodoc:
       # MRI 1.8.6 or YARV 1.9.1 or TruffleRuby
       @driver_type ||= if (!defined?(RUBY_ENGINE) || RUBY_ENGINE == "ruby" || RUBY_ENGINE == "truffleruby") && defined?(OCI8)
         :oci
@@ -67,18 +67,18 @@ def jdbc?
       @raw_driver == :jdbc
     end
 
-    def logoff #:nodoc:
+    def logoff # :nodoc:
       # Rollback any uncommited transactions
       rollback
       # Common cleanup activities before logoff, should be called from particular driver method
       drop_session_ruby_temporary_tables
     end
 
-    def commit #:nodoc:
+    def commit # :nodoc:
       raise NoMethodError, "Not implemented for this raw driver"
     end
 
-    def rollback #:nodoc:
+    def rollback # :nodoc:
       raise NoMethodError, "Not implemented for this raw driver"
     end
 
@@ -98,21 +98,21 @@ def prefetch_rows=(value)
       raise NoMethodError, "Not implemented for this raw driver"
     end
 
-    def select_first(sql, *bindvars) #:nodoc:
+    def select_first(sql, *bindvars) # :nodoc:
       cursor = cursor_from_query(sql, bindvars, prefetch_rows: 1)
       cursor.fetch
     ensure
       cursor.close rescue nil
     end
 
-    def select_hash_first(sql, *bindvars) #:nodoc:
+    def select_hash_first(sql, *bindvars) # :nodoc:
       cursor = cursor_from_query(sql, bindvars, prefetch_rows: 1)
       cursor.fetch_hash
     ensure
       cursor.close rescue nil
     end
 
-    def select_all(sql, *bindvars, &block) #:nodoc:
+    def select_all(sql, *bindvars, &block) # :nodoc:
       cursor = cursor_from_query(sql, bindvars)
       results = []
       row_count = 0
@@ -129,7 +129,7 @@ def select_all(sql, *bindvars, &block) #:nodoc:
       cursor.close rescue nil
     end
 
-    def select_hash_all(sql, *bindvars, &block) #:nodoc:
+    def select_hash_all(sql, *bindvars, &block) # :nodoc:
       cursor = cursor_from_query(sql, bindvars)
       results = []
       row_count = 0
@@ -146,11 +146,11 @@ def select_hash_all(sql, *bindvars, &block) #:nodoc:
       cursor.close rescue nil
     end
 
-    def exec(sql, *bindvars) #:nodoc:
+    def exec(sql, *bindvars) # :nodoc:
       raise NoMethodError, "Not implemented for this raw driver"
     end
 
-    def parse(sql) #:nodoc:
+    def parse(sql) # :nodoc:
       raise NoMethodError, "Not implemented for this raw driver"
     end
 
@@ -181,7 +181,7 @@ def fetch_hash
 
     # all_synonyms view is quite slow therefore
     # this implementation is overriden in OCI connection with faster native OCI method
-    def describe_synonym(schema_name, synonym_name) #:nodoc:
+    def describe_synonym(schema_name, synonym_name) # :nodoc:
       select_first(
         "SELECT table_owner, table_name FROM all_synonyms WHERE owner = :owner AND synonym_name = :synonym_name",
         schema_name.to_s.upcase, synonym_name.to_s.upcase)

lib/plsql/helpers.rb

@@ -1,6 +1,6 @@
-module PLSQL #:nodoc:
-  module ArrayHelpers #:nodoc:
-    def self.to_hash(keys, values) #:nodoc:
+module PLSQL # :nodoc:
+  module ArrayHelpers # :nodoc:
+    def self.to_hash(keys, values) # :nodoc:
       (0...keys.size).inject({}) { |hash, i| hash[keys[i]] = values[i]; hash }
     end
   end

lib/plsql/jdbc_connection.rb

@@ -46,7 +46,7 @@
 end
 
 module PLSQL
-  class JDBCConnection < Connection  #:nodoc:
+  class JDBCConnection < Connection  # :nodoc:
     def self.create_raw(params)
       database = params[:database]
       url = if ENV["TNS_ADMIN"] && database && !params[:host] && !params[:url]
@@ -98,7 +98,7 @@ def exec(sql, *bindvars)
       cs.close rescue nil
     end
 
-    class CallableStatement #:nodoc:
+    class CallableStatement # :nodoc:
       def initialize(conn, sql)
         @sql = sql
         @connection = conn
@@ -145,7 +145,7 @@ def bind_param_index(key)
         end
     end
 
-    class Cursor #:nodoc:
+    class Cursor # :nodoc:
       include Connection::CursorCommon
 
       attr_reader :result_set

lib/plsql/oci_connection.rb

@@ -24,7 +24,7 @@
 end
 
 module PLSQL
-  class OCIConnection < Connection #:nodoc:
+  class OCIConnection < Connection # :nodoc:
     def self.create_raw(params)
       connection_string = if params[:host]
         "//#{params[:host]}:#{params[:port] || 1521}/#{params[:database]}"
@@ -64,7 +64,7 @@ def exec(sql, *bindvars)
       true
     end
 
-    class Cursor #:nodoc:
+    class Cursor # :nodoc:
       include Connection::CursorCommon
 
       attr_reader :raw_cursor

lib/plsql/package.rb

@@ -1,5 +1,5 @@
 module PLSQL
-  module PackageClassMethods #:nodoc:
+  module PackageClassMethods # :nodoc:
     def find(schema, package)
       package_name = package.to_s.upcase
       find_in_schema(schema, package_name) || find_by_synonym(schema, package_name)
@@ -32,7 +32,7 @@ def find_by_synonym(schema, package_name)
     end
   end
 
-  class Package #:nodoc:
+  class Package # :nodoc:
     extend PackageClassMethods
 
     def initialize(schema, package, override_schema_name = nil)

lib/plsql/procedure.rb

@@ -1,5 +1,5 @@
 module PLSQL
-  module ProcedureClassMethods #:nodoc:
+  module ProcedureClassMethods # :nodoc:
     def find(schema, procedure, package = nil, override_schema_name = nil)
       if package.nil?
         if (row = schema.select_first(
@@ -53,12 +53,12 @@ def procedure_object_id_src(schema)
       end
   end
 
-  module ProcedureCommon #:nodoc:
+  module ProcedureCommon # :nodoc:
     attr_reader :arguments, :argument_list, :out_list, :return
     attr_reader :schema, :schema_name, :package, :procedure
 
     # return type string from metadata that can be used in DECLARE block or table definition
-    def self.type_to_sql(metadata) #:nodoc:
+    def self.type_to_sql(metadata) # :nodoc:
       case metadata[:data_type]
       when "NUMBER"
         precision, scale = metadata[:data_precision], metadata[:data_scale]
@@ -82,15 +82,15 @@ def self.type_to_sql(metadata) #:nodoc:
     end
 
     # get procedure argument metadata from data dictionary
-    def get_argument_metadata #:nodoc:
+    def get_argument_metadata # :nodoc:
       if (@schema.connection.database_version <=> [18, 0, 0, 0]) >= 0
         get_argument_metadata_from_18c
       else
         get_argument_metadata_below_18c
       end
     end
 
-    def get_argument_metadata_below_18c #:nodoc:
+    def get_argument_metadata_below_18c # :nodoc:
       @arguments = {}
       @argument_list = {}
       @out_list = {}
@@ -209,7 +209,7 @@ def get_argument_metadata_below_18c #:nodoc:
     end
 
     # get procedure argument metadata from data dictionary
-    def get_argument_metadata_from_18c #:nodoc:
+    def get_argument_metadata_from_18c # :nodoc:
       @arguments = {}
       @argument_list = {}
       @out_list = {}
@@ -304,15 +304,15 @@ def get_argument_metadata_from_18c #:nodoc:
       construct_argument_list_for_overloads
     end
 
-    def construct_argument_list_for_overloads #:nodoc:
+    def construct_argument_list_for_overloads # :nodoc:
       @overloads = @arguments.keys.sort
       @overloads.each do |overload|
         @argument_list[overload] = @arguments[overload].keys.sort { |k1, k2| @arguments[overload][k1][:position] <=> @arguments[overload][k2][:position] }
         @out_list[overload] = @argument_list[overload].select { |k| @arguments[overload][k][:in_out] =~ /OUT/ }
       end
     end
 
-    def ensure_tmp_tables_created(overload) #:nodoc:
+    def ensure_tmp_tables_created(overload) # :nodoc:
       return if @tmp_tables_created.nil? || @tmp_tables_created[overload]
       @tmp_table_names[overload] && @tmp_table_names[overload].each do |table_name, argument_metadata|
         sql = "CREATE GLOBAL TEMPORARY TABLE #{table_name} (\n"
@@ -336,7 +336,7 @@ def ensure_tmp_tables_created(overload) #:nodoc:
       @tmp_tables_created[overload] = true
     end
 
-    def build_sql_type_name(type_owner, type_package, type_name) #:nodoc:
+    def build_sql_type_name(type_owner, type_package, type_name) # :nodoc:
       if type_owner == nil || type_owner == "PUBLIC"
         type_owner_res = ""
       else
@@ -351,7 +351,7 @@ def build_sql_type_name(type_owner, type_package, type_name) #:nodoc:
       type_name_res && "#{type_owner_res}#{type_name_res}"
     end
 
-    def get_field_definitions(argument_metadata) #:nodoc:
+    def get_field_definitions(argument_metadata) # :nodoc:
       fields = {}
       case argument_metadata[:type_object_type]
       when "PACKAGE"
@@ -414,7 +414,7 @@ def get_field_definitions(argument_metadata) #:nodoc:
       fields
     end
 
-    def get_element_definition(argument_metadata) #:nodoc:
+    def get_element_definition(argument_metadata) # :nodoc:
       element_metadata = {}
       if collection_type?(argument_metadata[:data_type])
         case argument_metadata[:type_object_type]
@@ -516,21 +516,21 @@ def get_composite_type(type_owner, type_name, type_package)
     end
 
     PLSQL_COMPOSITE_TYPES = ["PL/SQL RECORD", "PL/SQL TABLE", "TABLE", "VARRAY", "REF CURSOR"].freeze
-    def composite_type?(data_type) #:nodoc:
+    def composite_type?(data_type) # :nodoc:
       PLSQL_COMPOSITE_TYPES.include? data_type
     end
 
     PLSQL_COLLECTION_TYPES = ["PL/SQL TABLE", "TABLE", "VARRAY"].freeze
-    def collection_type?(data_type) #:nodoc:
+    def collection_type?(data_type) # :nodoc:
       PLSQL_COLLECTION_TYPES.include? data_type
     end
 
-    def overloaded? #:nodoc:
+    def overloaded? # :nodoc:
       @overloaded
     end
   end
 
-  class Procedure #:nodoc:
+  class Procedure # :nodoc:
     extend ProcedureClassMethods
     include ProcedureCommon
 

lib/plsql/procedure_call.rb

@@ -1,5 +1,5 @@
 module PLSQL
-  class ProcedureCall #:nodoc:
+  class ProcedureCall # :nodoc:
     def initialize(procedure, args = [], options = {})
       @procedure = procedure
       @schema = @procedure.schema

lib/plsql/schema.rb

@@ -4,8 +4,8 @@ class Schema
 
     @@schemas = {}
 
-    class <<self
-      def find_or_new(connection_alias) #:nodoc:
+    class << self
+      def find_or_new(connection_alias) # :nodoc:
         connection_alias ||= :default
         if @@schemas[connection_alias]
           @@schemas[connection_alias]
@@ -15,7 +15,7 @@ def find_or_new(connection_alias) #:nodoc:
       end
     end
 
-    def initialize(raw_conn = nil, schema = nil, original_schema = nil) #:nodoc:
+    def initialize(raw_conn = nil, schema = nil, original_schema = nil) # :nodoc:
       self.connection = raw_conn
       @schema_name = schema ? schema.to_s.upcase : nil
       @original_schema = original_schema
@@ -25,11 +25,11 @@ def initialize(raw_conn = nil, schema = nil, original_schema = nil) #:nodoc:
     # Returns connection wrapper object (this is not raw OCI8 or JDBC connection!)
     attr_reader :connection
 
-    def root_schema #:nodoc:
+    def root_schema # :nodoc:
       @original_schema || self
     end
 
-    def raw_connection=(raw_conn) #:nodoc:
+    def raw_connection=(raw_conn) # :nodoc:
       @connection = raw_conn ? Connection.create(raw_conn) : nil
       reset_instance_variables
     end
@@ -117,7 +117,7 @@ def default_timezone=(value)
 
     # Same implementation as for ActiveRecord
     # DateTimes aren't aware of DST rules, so use a consistent non-DST offset when creating a DateTime with an offset in the local zone
-    def local_timezone_offset #:nodoc:
+    def local_timezone_offset # :nodoc:
       ::Time.local(2007).utc_offset.to_r / 86400
     end