Standard.rb automated fixes

Author: aidanharan

Gemfile

@@ -7,7 +7,7 @@ git_source(:github) { |repo| "https://github.com/#{repo}.git" }
 gemspec
 
 gem "bcrypt"
-gem "pg",      ">= 0.18.0"
+gem "pg", ">= 0.18.0"
 gem "sqlite3", ">= 1.6.6"
 gem "tzinfo-data", platforms: [:mingw, :mswin, :x64_mingw, :jruby]
 gem "benchmark-ips"
@@ -28,13 +28,13 @@ else
     require "yaml"
 
     spec = eval(File.read("activerecord-sqlserver-adapter.gemspec"))
-    ver  = spec.dependencies.detect { |d| d.name == "activerecord" }.requirement.requirements.first.last.version
+    ver = spec.dependencies.detect { |d| d.name == "activerecord" }.requirement.requirements.first.last.version
     major, minor, _tiny, pre = ver.split(".")
 
     if pre
       ver
     else
-      uri  = URI.parse("https://rubygems.org/api/v1/versions/activerecord.yaml")
+      uri = URI.parse("https://rubygems.org/api/v1/versions/activerecord.yaml")
       http = Net::HTTP.new(uri.host, uri.port)
       http.use_ssl = true
       http.verify_mode = OpenSSL::SSL::VERIFY_NONE
@@ -68,9 +68,7 @@ end
 group :guard do
   gem "guard"
   gem "guard-minitest"
-  gem "terminal-notifier-guard" if RbConfig::CONFIG["host_os"] =~ /darwin/
+  gem "terminal-notifier-guard" if /darwin/.match?(RbConfig::CONFIG["host_os"])
 end
 
-group :rubocop do
-  gem "rubocop", require: false
-end
+gem "standard", require: false

Guardfile

@@ -6,7 +6,7 @@ clearing :on
 notification :terminal_notifier if defined?(TerminalNotifier)
 ignore %r{debug\.log}
 
-ar_lib  = File.join ARTest::SQLServer.root_activerecord, "lib"
+ar_lib = File.join ARTest::SQLServer.root_activerecord, "lib"
 ar_test = File.join ARTest::SQLServer.root_activerecord, "test"
 
 guard :minitest, {
@@ -24,7 +24,7 @@ guard :minitest, {
   else
     watch(%r{^test/cases/\w+_test_sqlserver\.rb$})
     watch(%r{^test/cases/coerced_tests\.rb$}) { "test/cases/coerced_tests.rb" }
-    watch(%r{^lib/active_record/connection_adapters/sqlserver/([^/]+)\.rb$})  { |m| "test/cases/#{m[1]}_test_sqlserver.rb" }
+    watch(%r{^lib/active_record/connection_adapters/sqlserver/([^/]+)\.rb$}) { |m| "test/cases/#{m[1]}_test_sqlserver.rb" }
     watch(%r{^test/cases/helper_sqlserver\.rb$}) { "test" }
   end
 end

Rakefile

@@ -11,7 +11,7 @@ task default: [:test]
 namespace :test do
   ENV["ARCONN"] = "sqlserver"
 
-  %w(dblib).each do |mode|
+  %w[dblib].each do |mode|
     Rake::TestTask.new(mode) do |t|
       t.libs = ARTest::SQLServer.test_load_paths
       t.test_files = test_files

activerecord-sqlserver-adapter.gemspec

@@ -3,28 +3,27 @@
 version = File.read(File.expand_path("VERSION", __dir__)).strip
 
 Gem::Specification.new do |spec|
-  spec.name          = "activerecord-sqlserver-adapter"
-  spec.platform      = Gem::Platform::RUBY
-  spec.version       = version
+  spec.name = "activerecord-sqlserver-adapter"
+  spec.platform = Gem::Platform::RUBY
+  spec.version = version
 
   spec.required_ruby_version = ">= 3.2.0"
 
-  spec.license       = "MIT"
-  spec.authors       = ["Ken Collins", "Anna Carey", "Will Bond", "Murray Steele", "Shawn Balestracci", "Joe Rafaniello", "Tom Ward", "Aidan Haran"]
-  spec.email         = ["ken@metaskills.net", "will@wbond.net"]
-  spec.homepage      = "http://github.com/rails-sqlserver/activerecord-sqlserver-adapter"
-  spec.summary       = "ActiveRecord SQL Server Adapter."
-  spec.description   = "ActiveRecord SQL Server Adapter. SQL Server 2012 and upward."
+  spec.license = "MIT"
+  spec.authors = ["Ken Collins", "Anna Carey", "Will Bond", "Murray Steele", "Shawn Balestracci", "Joe Rafaniello", "Tom Ward", "Aidan Haran"]
+  spec.email = ["ken@metaskills.net", "will@wbond.net"]
+  spec.homepage = "http://github.com/rails-sqlserver/activerecord-sqlserver-adapter"
+  spec.summary = "ActiveRecord SQL Server Adapter."
+  spec.description = "ActiveRecord SQL Server Adapter. SQL Server 2012 and upward."
 
-  spec.metadata      = {
+  spec.metadata = {
     "bug_tracker_uri" => "https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/issues",
     "changelog_uri" => "https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/blob/v#{version}/CHANGELOG.md",
-    "source_code_uri" => "https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/tree/v#{version}",
+    "source_code_uri" => "https://github.com/rails-sqlserver/activerecord-sqlserver-adapter/tree/v#{version}"
   }
 
-  spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.files = `git ls-files -z`.split("\x0")
+  spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
   spec.add_dependency "activerecord", "~> 8.1.0.alpha"

lib/active_record/connection_adapters/sqlserver/core_ext/explain.rb

@@ -32,8 +32,7 @@ def unprepare_sqlserver_statement(sql, binds)
             executesql = executesql.match(SQLSERVER_STATEMENT_REGEXP).to_a[1]
 
             binds.each_with_index do |bind, index|
-
-              value = if bind.is_a?(::ActiveModel::Attribute)  then
+              value = if bind.is_a?(::ActiveModel::Attribute)
                 connection.quote(bind.value_for_database)
               else
                 connection.quote(bind)

lib/active_record/connection_adapters/sqlserver/core_ext/finder_methods.rb

@@ -24,16 +24,16 @@ def construct_relation_for_exists(conditions)
           def _construct_relation_for_exists(conditions)
             conditions = sanitize_forbidden_attributes(conditions)
 
-            if distinct_value && offset_value
+            relation = if distinct_value && offset_value
               # Start of monkey-patch
               if select_values.present?
-                relation = order(*select_values).limit!(1)
+                order(*select_values).limit!(1)
               else
-                relation = except(:order).limit!(1)
+                except(:order).limit!(1)
               end
               # End of monkey-patch
             else
-              relation = except(:select, :distinct, :order)._select!(Arel.sql(::ActiveRecord::FinderMethods::ONE_AS_ONE, retryable: true)).limit!(1)
+              except(:select, :distinct, :order)._select!(Arel.sql(::ActiveRecord::FinderMethods::ONE_AS_ONE, retryable: true)).limit!(1)
             end
 
             case conditions

lib/active_record/connection_adapters/sqlserver/database_statements.rb

@@ -15,15 +15,15 @@ def write_query?(sql) # :nodoc:
 
         def perform_query(raw_connection, sql, binds, type_casted_binds, prepare:, notification_payload:, batch:)
           result, affected_rows = if id_insert_table_name = query_requires_identity_insert?(sql)
-                                    # If the table name is a view, we need to get the base table name for enabling identity insert.
-                                    id_insert_table_name = view_table_name(id_insert_table_name) if view_exists?(id_insert_table_name)
+            # If the table name is a view, we need to get the base table name for enabling identity insert.
+            id_insert_table_name = view_table_name(id_insert_table_name) if view_exists?(id_insert_table_name)
 
-                                    with_identity_insert_enabled(id_insert_table_name, raw_connection) do
-                                      internal_exec_sql_query(sql, raw_connection)
-                                    end
-                                  else
-                                    internal_exec_sql_query(sql, raw_connection)
-                                  end
+            with_identity_insert_enabled(id_insert_table_name, raw_connection) do
+              internal_exec_sql_query(sql, raw_connection)
+            end
+          else
+            internal_exec_sql_query(sql, raw_connection)
+          end
 
           verified!
           notification_payload[:affected_rows] = affected_rows
@@ -41,7 +41,7 @@ def cast_result(raw_result)
 
         # Returns the affected rows from results.
         def affected_rows(raw_result)
-          raw_result&.first&.fetch('AffectedRows', nil)
+          raw_result&.first&.fetch("AffectedRows", nil)
         end
 
         # Returns the affected rows from results or handle.
@@ -66,19 +66,19 @@ def internal_exec_sql_query(sql, conn)
           handle = internal_raw_execute(sql, conn)
           results = handle_to_names_and_values(handle, ar_result: true)
 
-          return results, affected_rows_from_results_or_handle(results, handle)
+          [results, affected_rows_from_results_or_handle(results, handle)]
         ensure
           finish_statement_handle(handle)
         end
 
         def exec_delete(sql, name = nil, binds = [])
           sql = sql.dup << "; SELECT @@ROWCOUNT AS AffectedRows"
-          super(sql, name, binds)
+          super
         end
 
         def exec_update(sql, name = nil, binds = [])
           sql = sql.dup << "; SELECT @@ROWCOUNT AS AffectedRows"
-          super(sql, name, binds)
+          super
         end
 
         def begin_db_transaction
@@ -155,14 +155,14 @@ def default_insert_value(column)
         private :default_insert_value
 
         def build_insert_sql(insert) # :nodoc:
-          sql = +"INSERT #{insert.into}"
+          sql = "INSERT #{insert.into}"
 
           if returning = insert.send(:insert_all).returning
             returning_sql = if returning.is_a?(String)
-                              returning
-                            else
-                              Array(returning).map { |column| "INSERTED.#{quote_column_name(column)}" }.join(", ")
-                            end
+              returning
+            else
+              Array(returning).map { |column| "INSERTED.#{quote_column_name(column)}" }.join(", ")
+            end
             sql << " OUTPUT #{returning_sql}"
           end
 
@@ -174,17 +174,17 @@ def build_insert_sql(insert) # :nodoc:
 
         def execute_procedure(proc_name, *variables)
           vars = if variables.any? && variables.first.is_a?(Hash)
-                   variables.first.map { |k, v| "@#{k} = #{quote(v)}" }
-                 else
-                   variables.map { |v| quote(v) }
-                 end.join(", ")
+            variables.first.map { |k, v| "@#{k} = #{quote(v)}" }
+          else
+            variables.map { |v| quote(v) }
+          end.join(", ")
           sql = "EXEC #{proc_name} #{vars}".strip
 
           log(sql, "Execute Procedure") do |notification_payload|
             with_raw_connection do |conn|
               result = internal_raw_execute(sql, conn)
               verified!
-              options = { as: :hash, cache_rows: true, timezone: ActiveRecord.default_timezone || :utc }
+              options = {as: :hash, cache_rows: true, timezone: ActiveRecord.default_timezone || :utc}
 
               result.each(options) do |row|
                 r = row.with_indifferent_access
@@ -218,7 +218,7 @@ def user_options
 
           rows = select_rows("DBCC USEROPTIONS WITH NO_INFOMSGS", "SCHEMA")
           rows = rows.first if rows.size == 2 && rows.last.empty?
-          rows.reduce(HashWithIndifferentAccess.new) do |values, row|
+          rows.each_with_object(HashWithIndifferentAccess.new) do |row, values|
             if row.instance_of? Hash
               set_option = row.values[0].gsub(/\s+/, "_")
               user_value = row.values[1]
@@ -227,7 +227,6 @@ def user_options
               user_value = row[1]
             end
             values[set_option] = user_value
-            values
           end
         end
 
@@ -281,45 +280,45 @@ def sql_for_insert(sql, pk, binds, returning)
           end
 
           sql = if pk && use_output_inserted? && !database_prefix_remote_server?
-                  table_name ||= get_table_name(sql)
-                  exclude_output_inserted = exclude_output_inserted_table_name?(table_name, sql)
-
-                  if exclude_output_inserted
-                    pk_and_types = Array(pk).map do |subkey|
-                      {
-                        quoted: SQLServer::Utils.extract_identifiers(subkey).quoted,
-                        id_sql_type: exclude_output_inserted_id_sql_type(subkey, exclude_output_inserted)
-                      }
-                    end
-
-                    <<~SQL.squish
-                      DECLARE @ssaIdInsertTable table (#{pk_and_types.map { |pk_and_type| "#{pk_and_type[:quoted]} #{pk_and_type[:id_sql_type]}"}.join(", ") });
-                      #{sql.dup.insert sql.index(/ (DEFAULT )?VALUES/i), " OUTPUT #{ pk_and_types.map { |pk_and_type| "INSERTED.#{pk_and_type[:quoted]}" }.join(", ") } INTO @ssaIdInsertTable"}
-                      SELECT #{pk_and_types.map {|pk_and_type| "CAST(#{pk_and_type[:quoted]} AS #{pk_and_type[:id_sql_type]}) #{pk_and_type[:quoted]}"}.join(", ")} FROM @ssaIdInsertTable
-                    SQL
-                  else
-                    returning_columns = returning || Array(pk)
-
-                    if returning_columns.any?
-                      returning_columns_statements = returning_columns.map { |c| " INSERTED.#{SQLServer::Utils.extract_identifiers(c).quoted}" }
-                      sql.dup.insert sql.index(/ (DEFAULT )?VALUES/i), " OUTPUT" + returning_columns_statements.join(",")
-                    else
-                      sql
-                    end
-                  end
-                else
-                  "#{sql}; SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident"
-                end
+            table_name ||= get_table_name(sql)
+            exclude_output_inserted = exclude_output_inserted_table_name?(table_name, sql)
+
+            if exclude_output_inserted
+              pk_and_types = Array(pk).map do |subkey|
+                {
+                  quoted: SQLServer::Utils.extract_identifiers(subkey).quoted,
+                  id_sql_type: exclude_output_inserted_id_sql_type(subkey, exclude_output_inserted)
+                }
+              end
+
+              <<~SQL.squish
+                DECLARE @ssaIdInsertTable table (#{pk_and_types.map { |pk_and_type| "#{pk_and_type[:quoted]} #{pk_and_type[:id_sql_type]}" }.join(", ")});
+                #{sql.dup.insert sql.index(/ (DEFAULT )?VALUES/i), " OUTPUT #{pk_and_types.map { |pk_and_type| "INSERTED.#{pk_and_type[:quoted]}" }.join(", ")} INTO @ssaIdInsertTable"}
+                SELECT #{pk_and_types.map { |pk_and_type| "CAST(#{pk_and_type[:quoted]} AS #{pk_and_type[:id_sql_type]}) #{pk_and_type[:quoted]}" }.join(", ")} FROM @ssaIdInsertTable
+              SQL
+            else
+              returning_columns = returning || Array(pk)
+
+              if returning_columns.any?
+                returning_columns_statements = returning_columns.map { |c| " INSERTED.#{SQLServer::Utils.extract_identifiers(c).quoted}" }
+                sql.dup.insert sql.index(/ (DEFAULT )?VALUES/i), " OUTPUT" + returning_columns_statements.join(",")
+              else
+                sql
+              end
+            end
+          else
+            "#{sql}; SELECT CAST(SCOPE_IDENTITY() AS bigint) AS Ident"
+          end
 
           [sql, binds]
         end
 
         # === SQLServer Specific ======================================== #
 
         def set_identity_insert(table_name, conn, enable)
-          internal_raw_execute("SET IDENTITY_INSERT #{table_name} #{enable ? 'ON' : 'OFF'}", conn , perform_do: true)
+          internal_raw_execute("SET IDENTITY_INSERT #{table_name} #{enable ? "ON" : "OFF"}", conn, perform_do: true)
         rescue Exception
-          raise ActiveRecordError, "IDENTITY_INSERT could not be turned #{enable ? 'ON' : 'OFF'} for table #{table_name}"
+          raise ActiveRecordError, "IDENTITY_INSERT could not be turned #{enable ? "ON" : "OFF"} for table #{table_name}"
         end
 
         # === SQLServer Specific (Executing) ============================ #
@@ -350,9 +349,9 @@ def sp_executesql_sql_type(attr)
           value = active_model_attribute?(attr) ? attr.value_for_database : attr
 
           if value.is_a?(Numeric)
-            value > 2_147_483_647 ? "bigint".freeze : "int".freeze
+            (value > 2_147_483_647) ? "bigint" : "int"
           else
-            "nvarchar(max)".freeze
+            "nvarchar(max)"
           end
         end
 
@@ -418,7 +417,7 @@ def query_requires_identity_insert?(sql)
           raw_table_name = get_raw_table_name(sql)
           id_column = identity_columns(raw_table_name).first
 
-          id_column && sql =~ /^\s*(INSERT|EXEC sp_executesql N'INSERT)[^(]+\([^)]*\b(#{id_column.name})\b,?[^)]*\)/i ? SQLServer::Utils.extract_identifiers(raw_table_name).quoted : false
+          (id_column && sql =~ /^\s*(INSERT|EXEC sp_executesql N'INSERT)[^(]+\([^)]*\b(#{id_column.name})\b,?[^)]*\)/i) ? SQLServer::Utils.extract_identifiers(raw_table_name).quoted : false
         end
 
         def insert_sql?(sql)

lib/active_record/connection_adapters/sqlserver/database_tasks.rb

@@ -32,20 +32,19 @@ def collation
         private
 
         def create_database_options(options = {})
-          keys  = [:collate]
+          keys = [:collate]
           copts = @connection_parameters
-          options = {
+          {
             collate: copts[:collation]
           }.merge(options.symbolize_keys).select { |_, v|
             v.present?
           }.slice(*keys).map { |k, v|
             "#{k.to_s.upcase} #{v}"
           }.join(" ")
-          options
         end
 
         def create_database_edition_options(options = {})
-          keys  = [:maxsize, :edition, :service_objective]
+          keys = [:maxsize, :edition, :service_objective]
           copts = @connection_parameters
           edition_options = {
             maxsize: copts[:azure_maxsize],