applies new string literal convention in activerecord/lib

The current code base is not uniform. After some discussion,
we have chosen to go with double quotes by default.

1 files changed, 48 insertions, 48 deletions

diff --git a/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb b/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb
index 4cf6d4b14a..55c5fcafa6 100644
--- a/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb
+++ b/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb
@@ -1,4 +1,4 @@
-require 'active_support/core_ext/string/strip'
+require "active_support/core_ext/string/strip"
 
 module ActiveRecord
   module ConnectionAdapters
@@ -36,7 +36,7 @@ module ActiveRecord
         #   create_database config[:database], config
         #   create_database 'foo_development', encoding: 'unicode'
         def create_database(name, options = {})
-          options = { encoding: 'utf8' }.merge!(options.symbolize_keys)
+          options = { encoding: "utf8" }.merge!(options.symbolize_keys)
 
           option_string = options.inject("") do |memo, (key, value)|
             memo += case key
@@ -78,11 +78,11 @@ module ActiveRecord
             MSG
           end
 
-          select_values("SELECT tablename FROM pg_tables WHERE schemaname = ANY(current_schemas(false))", 'SCHEMA')
+          select_values("SELECT tablename FROM pg_tables WHERE schemaname = ANY(current_schemas(false))", "SCHEMA")
         end
 
         def data_sources # :nodoc
-          select_values(<<-SQL, 'SCHEMA')
+          select_values(<<-SQL, "SCHEMA")
             SELECT c.relname
             FROM pg_class c
             LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
@@ -108,7 +108,7 @@ module ActiveRecord
           name = Utils.extract_schema_qualified_name(name.to_s)
           return false unless name.identifier
 
-          select_value(<<-SQL, 'SCHEMA').to_i > 0
+          select_value(<<-SQL, "SCHEMA").to_i > 0
               SELECT COUNT(*)
               FROM pg_class c
               LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
@@ -119,7 +119,7 @@ module ActiveRecord
         end
 
         def views # :nodoc:
-          select_values(<<-SQL, 'SCHEMA')
+          select_values(<<-SQL, "SCHEMA")
             SELECT c.relname
             FROM pg_class c
             LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
@@ -132,7 +132,7 @@ module ActiveRecord
           name = Utils.extract_schema_qualified_name(view_name.to_s)
           return false unless name.identifier
 
-          select_values(<<-SQL, 'SCHEMA').any?
+          select_values(<<-SQL, "SCHEMA").any?
             SELECT c.relname
             FROM pg_class c
             LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
@@ -148,7 +148,7 @@ module ActiveRecord
 
         # Returns true if schema exists.
         def schema_exists?(name)
-          select_value("SELECT COUNT(*) FROM pg_namespace WHERE nspname = '#{name}'", 'SCHEMA').to_i > 0
+          select_value("SELECT COUNT(*) FROM pg_namespace WHERE nspname = '#{name}'", "SCHEMA").to_i > 0
         end
 
         # Verifies existence of an index with a given name.
@@ -156,7 +156,7 @@ module ActiveRecord
           table = Utils.extract_schema_qualified_name(table_name.to_s)
           index = Utils.extract_schema_qualified_name(index_name.to_s)
 
-          select_value(<<-SQL, 'SCHEMA').to_i > 0
+          select_value(<<-SQL, "SCHEMA").to_i > 0
             SELECT COUNT(*)
             FROM pg_class t
             INNER JOIN pg_index d ON t.oid = d.indrelid
@@ -173,7 +173,7 @@ module ActiveRecord
         def indexes(table_name, name = nil)
           table = Utils.extract_schema_qualified_name(table_name.to_s)
 
-          result = query(<<-SQL, 'SCHEMA')
+          result = query(<<-SQL, "SCHEMA")
             SELECT distinct i.relname, d.indisunique, d.indkey, pg_get_indexdef(d.indexrelid), t.oid,
                             pg_catalog.obj_description(i.oid, 'pg_class') AS comment,
             (SELECT COUNT(*) FROM pg_opclass o
@@ -246,7 +246,7 @@ module ActiveRecord
         def table_comment(table_name) # :nodoc:
           name = Utils.extract_schema_qualified_name(table_name.to_s)
           if name.identifier
-            select_value(<<-SQL.strip_heredoc, 'SCHEMA')
+            select_value(<<-SQL.strip_heredoc, "SCHEMA")
               SELECT pg_catalog.obj_description(c.oid, 'pg_class')
               FROM pg_catalog.pg_class c
                 LEFT JOIN pg_namespace n ON n.oid = c.relnamespace
@@ -259,32 +259,32 @@ module ActiveRecord
 
         # Returns the current database name.
         def current_database
-          select_value('select current_database()', 'SCHEMA')
+          select_value("select current_database()", "SCHEMA")
         end
 
         # Returns the current schema name.
         def current_schema
-          select_value('SELECT current_schema', 'SCHEMA')
+          select_value("SELECT current_schema", "SCHEMA")
         end
 
         # Returns the current database encoding format.
         def encoding
-          select_value("SELECT pg_encoding_to_char(encoding) FROM pg_database WHERE datname LIKE '#{current_database}'", 'SCHEMA')
+          select_value("SELECT pg_encoding_to_char(encoding) FROM pg_database WHERE datname LIKE '#{current_database}'", "SCHEMA")
         end
 
         # Returns the current database collation.
         def collation
-          select_value("SELECT datcollate FROM pg_database WHERE datname LIKE '#{current_database}'", 'SCHEMA')
+          select_value("SELECT datcollate FROM pg_database WHERE datname LIKE '#{current_database}'", "SCHEMA")
         end
 
         # Returns the current database ctype.
         def ctype
-          select_value("SELECT datctype FROM pg_database WHERE datname LIKE '#{current_database}'", 'SCHEMA')
+          select_value("SELECT datctype FROM pg_database WHERE datname LIKE '#{current_database}'", "SCHEMA")
         end
 
         # Returns an array of schema names.
         def schema_names
-          select_values(<<-SQL, 'SCHEMA')
+          select_values(<<-SQL, "SCHEMA")
             SELECT nspname
               FROM pg_namespace
              WHERE nspname !~ '^pg_.*'
@@ -310,28 +310,28 @@ module ActiveRecord
         # This should be not be called manually but set in database.yml.
         def schema_search_path=(schema_csv)
           if schema_csv
-            execute("SET search_path TO #{schema_csv}", 'SCHEMA')
+            execute("SET search_path TO #{schema_csv}", "SCHEMA")
             @schema_search_path = schema_csv
           end
         end
 
         # Returns the active schema search path.
         def schema_search_path
-          @schema_search_path ||= select_value('SHOW search_path', 'SCHEMA')
+          @schema_search_path ||= select_value("SHOW search_path", "SCHEMA")
         end
 
         # Returns the current client message level.
         def client_min_messages
-          select_value('SHOW client_min_messages', 'SCHEMA')
+          select_value("SHOW client_min_messages", "SCHEMA")
         end
 
         # Set the client message level.
         def client_min_messages=(level)
-          execute("SET client_min_messages TO '#{level}'", 'SCHEMA')
+          execute("SET client_min_messages TO '#{level}'", "SCHEMA")
         end
 
         # Returns the sequence name for a table's primary key or some other specified key.
-        def default_sequence_name(table_name, pk = 'id') #:nodoc:
+        def default_sequence_name(table_name, pk = "id") #:nodoc:
           result = serial_sequence(table_name, pk)
           return nil unless result
           Utils.extract_schema_qualified_name(result).to_s
@@ -340,7 +340,7 @@ module ActiveRecord
         end
 
         def serial_sequence(table, column)
-          select_value("SELECT pg_get_serial_sequence('#{table}', '#{column}')", 'SCHEMA')
+          select_value("SELECT pg_get_serial_sequence('#{table}', '#{column}')", "SCHEMA")
         end
 
         # Sets the sequence of a table's primary key to the specified value.
@@ -351,7 +351,7 @@ module ActiveRecord
             if sequence
               quoted_sequence = quote_table_name(sequence)
 
-              select_value("SELECT setval('#{quoted_sequence}', #{value})", 'SCHEMA')
+              select_value("SELECT setval('#{quoted_sequence}', #{value})", "SCHEMA")
             else
               @logger.warn "#{table} has primary key #{pk} with no default sequence." if @logger
             end
@@ -374,7 +374,7 @@ module ActiveRecord
           if pk && sequence
             quoted_sequence = quote_table_name(sequence)
 
-            select_value(<<-end_sql, 'SCHEMA')
+            select_value(<<-end_sql, "SCHEMA")
               SELECT setval('#{quoted_sequence}', (SELECT COALESCE(MAX(#{quote_column_name pk})+(SELECT increment_by FROM #{quoted_sequence}), (SELECT min_value FROM #{quoted_sequence})) FROM #{quote_table_name(table)}), false)
             end_sql
           end
@@ -384,7 +384,7 @@ module ActiveRecord
         def pk_and_sequence_for(table) #:nodoc:
           # First try looking for a sequence with a dependency on the
           # given table's primary key.
-          result = query(<<-end_sql, 'SCHEMA')[0]
+          result = query(<<-end_sql, "SCHEMA")[0]
             SELECT attr.attname, nsp.nspname, seq.relname
             FROM pg_class      seq,
                  pg_attribute  attr,
@@ -404,7 +404,7 @@ module ActiveRecord
           end_sql
 
           if result.nil? or result.empty?
-            result = query(<<-end_sql, 'SCHEMA')[0]
+            result = query(<<-end_sql, "SCHEMA")[0]
               SELECT attr.attname, nsp.nspname,
                 CASE
                   WHEN pg_get_expr(def.adbin, def.adrelid) !~* 'nextval' THEN NULL
@@ -435,7 +435,7 @@ module ActiveRecord
         end
 
         def primary_keys(table_name) # :nodoc:
-          select_values(<<-SQL.strip_heredoc, 'SCHEMA')
+          select_values(<<-SQL.strip_heredoc, "SCHEMA")
             WITH pk_constraint AS (
               SELECT conrelid, unnest(conkey) AS connum FROM pg_constraint
               WHERE contype = 'p'
@@ -583,7 +583,7 @@ module ActiveRecord
         end
 
         def foreign_keys(table_name)
-          fk_info = select_all(<<-SQL.strip_heredoc, 'SCHEMA')
+          fk_info = select_all(<<-SQL.strip_heredoc, "SCHEMA")
             SELECT t2.oid::regclass::text AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete
             FROM pg_constraint c
             JOIN pg_class t1 ON c.conrelid = t1.oid
@@ -599,23 +599,23 @@ module ActiveRecord
 
           fk_info.map do |row|
             options = {
-              column: row['column'],
-              name: row['name'],
-              primary_key: row['primary_key']
+              column: row["column"],
+              name: row["name"],
+              primary_key: row["primary_key"]
             }
 
-            options[:on_delete] = extract_foreign_key_action(row['on_delete'])
-            options[:on_update] = extract_foreign_key_action(row['on_update'])
+            options[:on_delete] = extract_foreign_key_action(row["on_delete"])
+            options[:on_update] = extract_foreign_key_action(row["on_update"])
 
-            ForeignKeyDefinition.new(table_name, row['to_table'], options)
+            ForeignKeyDefinition.new(table_name, row["to_table"], options)
           end
         end
 
         def extract_foreign_key_action(specifier) # :nodoc:
           case specifier
-          when 'c'; :cascade
-          when 'n'; :nullify
-          when 'r'; :restrict
+          when "c"; :cascade
+          when "n"; :nullify
+          when "r"; :restrict
           end
         end
 
@@ -626,32 +626,32 @@ module ActiveRecord
         # Maps logical Rails types to PostgreSQL-specific data types.
         def type_to_sql(type, limit = nil, precision = nil, scale = nil, array = nil)
           sql = case type.to_s
-          when 'binary'
+          when "binary"
             # PostgreSQL doesn't support limits on binary (bytea) columns.
             # The hard limit is 1GB, because of a 32-bit size field, and TOAST.
             case limit
             when nil, 0..0x3fffffff; super(type)
             else raise(ActiveRecordError, "No binary type has byte size #{limit}.")
             end
-          when 'text'
+          when "text"
             # PostgreSQL doesn't support limits on text columns.
             # The hard limit is 1GB, according to section 8.3 in the manual.
             case limit
             when nil, 0..0x3fffffff; super(type)
             else raise(ActiveRecordError, "The limit on text can be at most 1GB - 1byte.")
             end
-          when 'integer'
+          when "integer"
             case limit
-            when 1, 2; 'smallint'
-            when nil, 3, 4; 'integer'
-            when 5..8; 'bigint'
+            when 1, 2; "smallint"
+            when nil, 3, 4; "integer"
+            when 5..8; "bigint"
             else raise(ActiveRecordError, "No integer type has byte size #{limit}. Use a numeric with scale 0 instead.")
             end
           else
             super(type, limit, precision, scale)
           end
 
-          sql << '[]' if array && type != :primary_key
+          sql << "[]" if array && type != :primary_key
           sql
         end
 
@@ -662,11 +662,11 @@ module ActiveRecord
               # Convert Arel node to string
               s = s.to_sql unless s.is_a?(String)
               # Remove any ASC/DESC modifiers
-              s.gsub(/\s+(?:ASC|DESC)\b/i, '')
-               .gsub(/\s+NULLS\s+(?:FIRST|LAST)\b/i, '')
+              s.gsub(/\s+(?:ASC|DESC)\b/i, "")
+               .gsub(/\s+NULLS\s+(?:FIRST|LAST)\b/i, "")
             }.reject(&:blank?).map.with_index { |column, i| "#{column} AS alias_#{i}" }
 
-          [super, *order_columns].join(', ')
+          [super, *order_columns].join(", ")
         end
 
         def fetch_type_metadata(column_name, sql_type, oid, fmod)