schema_plus_core 2.2.2 → 3.1.0.beta.3

data/lib/schema_plus/core/active_record/connection_adapters/mysql2_adapter.rb

@@ -1,24 +1,34 @@
+# frozen_string_literal: true
+
 module SchemaPlus
   module Core
     module ActiveRecord
       module ConnectionAdapters
         module Mysql2Adapter
 
-          def change_column(table_name, name, type, options = {})
+          def change_column(table_name, name, type, **options)
             SchemaMonkey::Middleware::Migration::Column.start(caller: self, operation: :change, table_name: table_name, column_name: name, type: type, options: options.deep_dup) do |env|
-              super env.table_name, env.column_name, env.type, env.options
+              super env.table_name, env.column_name, env.type, **env.options
             end
           end
 
-          def add_index(table_name, column_names, options={})
-            SchemaMonkey::Middleware::Migration::Index.start(caller: self, operation: :add, table_name: table_name, column_names: column_names, options: options.deep_dup) do |env|
-              super env.table_name, env.column_names, env.options
+          if Gem::Version.new(::ActiveRecord::VERSION::STRING) < Gem::Version.new('6.1')
+            def add_index(table_name, column_names, options = {})
+              SchemaMonkey::Middleware::Migration::Index.start(caller: self, operation: :add, table_name: table_name, column_names: column_names, options: options.deep_dup) do |env|
+                super env.table_name, env.column_names, env.options
+              end
+            end
+          else
+            def add_index(table_name, column_names, **options)
+              SchemaMonkey::Middleware::Migration::Index.start(caller: self, operation: :add, table_name: table_name, column_names: column_names, options: options.deep_dup) do |env|
+                super env.table_name, env.column_names, **env.options
+              end
             end
           end
 
-          def drop_table(table_name, options={})
+          def drop_table(table_name, **options)
             SchemaMonkey::Middleware::Migration::DropTable.start(connection: self, table_name: table_name, options: options.dup) do |env|
-              super env.table_name, env.options
+              super env.table_name, **env.options
             end
           end
 

data/lib/schema_plus/core/active_record/connection_adapters/postgresql/schema_dumper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SchemaPlus
   module Core
     module ActiveRecord
@@ -24,11 +26,15 @@ module SchemaPlus
               end
 
               def extensions(_)
-                SchemaMonkey::Middleware::Dumper::Initial.start(dumper: self, connection: @connection, dump: @dump, initial: @dump.initial) do |env|
-                  stream = StringIO.new
-                  super stream
-                  env.dump.initial << stream.string unless stream.string.blank?
-                end
+                stream = StringIO.new
+                super stream
+                @dump.extensions << stream.string unless stream.string.blank?
+              end
+
+              def types(_)
+                stream = StringIO.new
+                super stream
+                @dump.types << stream.string unless stream.string.blank?
               end
             end
           end

data/lib/schema_plus/core/active_record/connection_adapters/postgresql_adapter.rb

@@ -1,42 +1,34 @@
+# frozen_string_literal: true
+
 module SchemaPlus
   module Core
     module ActiveRecord
       module ConnectionAdapters
         module PostgresqlAdapter
-
-          # quick hack fix quoting of column default functions to allow eval() when we
-          # capture the stream.
-          #
-          # AR's PostgresqlAdapter#prepare_column_options wraps the
-          # function in double quotes, which doesn't work because the
-          # function itself may have doublequotes in it which don't get
-          # escaped properly.
-          #
-          # Arguably that's a bug in AR, but then again default function
-          # expressions don't work well in AR anyway.  (hence
-          # schema_plus_default_expr )
-          #
-          def prepare_column_options(column, *) # :nodoc:
-            spec = super
-            spec[:default] = "%q{#{column.default_function}}" if column.default_function
-            spec
-          end
-
-          def change_column(table_name, name, type, options = {})
+          
+          def change_column(table_name, name, type, **options)
             SchemaMonkey::Middleware::Migration::Column.start(caller: self, operation: :change, table_name: table_name, column_name: name, type: type, options: options.deep_dup) do |env|
-              super env.table_name, env.column_name, env.type, env.options
+              super env.table_name, env.column_name, env.type, **env.options
             end
           end
 
-          def add_index(table_name, column_names, options={})
-            SchemaMonkey::Middleware::Migration::Index.start(caller: self, operation: :add, table_name: table_name, column_names: column_names, options: options.deep_dup) do |env|
-              super env.table_name, env.column_names, env.options
+          if Gem::Version.new(::ActiveRecord::VERSION::STRING) < Gem::Version.new('6.1')
+            def add_index(table_name, column_names, options = {})
+              SchemaMonkey::Middleware::Migration::Index.start(caller: self, operation: :add, table_name: table_name, column_names: column_names, options: options.deep_dup) do |env|
+                super env.table_name, env.column_names, env.options
+              end
+            end
+          else
+            def add_index(table_name, column_names, **options)
+              SchemaMonkey::Middleware::Migration::Index.start(caller: self, operation: :add, table_name: table_name, column_names: column_names, options: options.deep_dup) do |env|
+                super env.table_name, env.column_names, **env.options
+              end
             end
           end
 
-          def drop_table(table_name, options={})
+          def drop_table(table_name, **options)
             SchemaMonkey::Middleware::Migration::DropTable.start(connection: self, table_name: table_name, options: options.dup) do |env|
-              super env.table_name, env.options
+              super env.table_name, **env.options
             end
           end
 
@@ -46,15 +38,15 @@ module SchemaPlus
             end
           end
 
-          def exec_cache(sql, name, binds)
-            SchemaMonkey::Middleware::Query::Exec.start(connection: self, sql: sql, query_name: name, binds: binds) { |env|
-              env.result = super env.sql, env.query_name, env.binds
+          def exec_cache(sql, name, binds, **options)
+            SchemaMonkey::Middleware::Query::Exec.start(connection: self, sql: sql, query_name: name, binds: binds, options: options) { |env|
+              env.result = super env.sql, env.query_name, env.binds, **env.options
             }.result
           end
 
-          def exec_no_cache(sql, name, binds)
-            SchemaMonkey::Middleware::Query::Exec.start(connection: self, sql: sql, query_name: name, binds: binds) { |env|
-              env.result = super env.sql, env.query_name, env.binds
+          def exec_no_cache(sql, name, binds, **options)
+            SchemaMonkey::Middleware::Query::Exec.start(connection: self, sql: sql, query_name: name, binds: binds, options: options) { |env|
+              env.result = super env.sql, env.query_name, env.binds, **env.options
             }.result
           end
 

data/lib/schema_plus/core/active_record/connection_adapters/sqlite3_adapter.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SchemaPlus
   module Core
     module ActiveRecord
@@ -10,15 +12,23 @@ module SchemaPlus
             end
           end
 
-          def change_column(table_name, name, type, options = {})
+          def change_column(table_name, name, type, **options)
             SchemaMonkey::Middleware::Migration::Column.start(caller: self, operation: :change, table_name: table_name, column_name: name, type: type, options: options.deep_dup) do |env|
-              super env.table_name, env.column_name, env.type, env.options
+              super env.table_name, env.column_name, env.type, **env.options
             end
           end
 
-          def add_index(table_name, column_names, options={})
-            SchemaMonkey::Middleware::Migration::Index.start(caller: self, operation: :add, table_name: table_name, column_names: column_names, options: options.deep_dup) do |env|
-              super env.table_name, env.column_names, env.options
+          if Gem::Version.new(::ActiveRecord::VERSION::STRING) < Gem::Version.new('6.1')
+            def add_index(table_name, column_names, options = {})
+              SchemaMonkey::Middleware::Migration::Index.start(caller: self, operation: :add, table_name: table_name, column_names: column_names, options: options.deep_dup) do |env|
+                super env.table_name, env.column_names, env.options
+              end
+            end
+          else
+            def add_index(table_name, column_names, **options)
+              SchemaMonkey::Middleware::Migration::Index.start(caller: self, operation: :add, table_name: table_name, column_names: column_names, options: options.deep_dup) do |env|
+                super env.table_name, env.column_names, **env.options
+              end
             end
           end
 

data/lib/schema_plus/core/active_record/connection_adapters/table_definition.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SchemaPlus
   module Core
     module ActiveRecord
@@ -7,29 +9,35 @@ module SchemaPlus
           def column(name, type, options = {})
             options = options.deep_dup
             SchemaMonkey::Middleware::Migration::Column.start(caller: self, operation: :define, table_name: self.name, column_name: name, type: type, implements_reference: options.delete(:_implements_reference), options: options) do |env|
-              super env.column_name, env.type, env.options
+              super env.column_name, env.type, **env.options
             end
           end
 
-          def references(name, options = {})
+          def references(name, **options)
             options = options.deep_dup
             SchemaMonkey::Middleware::Migration::Column.start(caller: self, operation: :define, table_name: self.name, column_name: "#{name}_id", type: :reference, options: options) do |env|
-              super env.column_name.sub(/_id$/, ''), env.options.merge(_implements_reference: true)
+              super env.column_name.sub(/_id$/, ''), **env.options.merge(_implements_reference: true)
             end
           end
 
-          def belongs_to(name, options = {})
+          def belongs_to(name, **options)
             options = options.deep_dup
             SchemaMonkey::Middleware::Migration::Column.start(caller: self, operation: :define, table_name: self.name, column_name: "#{name}_id", type: :reference, options: options) do |env|
-              super env.column_name.sub(/_id$/, ''), env.options.merge(_implements_reference: true)
+              super env.column_name.sub(/_id$/, ''), **env.options.merge(_implements_reference: true)
             end
           end
 
-          def index(*args)
-            options = args.extract_options!
-            column_name = args.first
-            SchemaMonkey::Middleware::Migration::Index.start(caller: self, operation: :define, table_name: self.name, column_names: column_name, options: options.deep_dup) do |env|
-              super env.column_names, env.options
+          if Gem::Version.new(::ActiveRecord::VERSION::STRING) < Gem::Version.new('6.1')
+            def index(column_name, options = {})
+              SchemaMonkey::Middleware::Migration::Index.start(caller: self, operation: :define, table_name: self.name, column_names: column_name, options: options.deep_dup) do |env|
+                super env.column_names, env.options
+              end
+            end
+          else
+            def index(column_name, **options)
+              SchemaMonkey::Middleware::Migration::Index.start(caller: self, operation: :define, table_name: self.name, column_names: column_name, options: options.deep_dup) do |env|
+                super env.column_names, **env.options
+              end
             end
           end
         end

data/lib/schema_plus/core/active_record/migration/command_recorder.rb

@@ -1,12 +1,14 @@
+# frozen_string_literal: true
+
 module SchemaPlus
   module Core
     module ActiveRecord
       module Migration
         module CommandRecorder
 
-          def add_column(table_name, column_name, type, options = {})
+          def add_column(table_name, column_name, type, **options)
             SchemaMonkey::Middleware::Migration::Column.start(caller: self, operation: :record, table_name: table_name, column_name: column_name, type: type, options: options.deep_dup) do |env|
-              super env.table_name, env.column_name, env.type, env.options
+              super env.table_name, env.column_name, env.type, **env.options
             end
           end
         end

data/lib/schema_plus/core/active_record/schema.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module SchemaPlus::Core
   module ActiveRecord
     module Schema

data/lib/schema_plus/core/active_record/schema_dumper.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'ostruct'
 require 'tsort'
 
@@ -30,20 +32,80 @@ module SchemaPlus
           @dump.trailer = stream.string
         end
 
-        def extensions(_)
+        def header(_)
           SchemaMonkey::Middleware::Dumper::Initial.start(dumper: self, connection: @connection, dump: @dump, initial: @dump.initial) do |env|
             stream = StringIO.new
             super stream
-            env.dump.initial << stream.string unless stream.string.blank?
+            env.dump.header = stream.string
           end
         end
 
+        def extensions(_)
+          stream = StringIO.new
+          super stream
+          @dump.extensions << stream.string unless stream.string.blank?
+        end
+
+        def types(_)
+          stream = StringIO.new
+          super stream
+          @dump.types << stream.string unless stream.string.blank?
+        end
+
         def tables(_)
           SchemaMonkey::Middleware::Dumper::Tables.start(dumper: self, connection: @connection, dump: @dump) do |env|
             super nil
           end
         end
 
+        TABLE_COLUMN_MATCHES = [
+            [ # first match expression index case
+                %r{
+                  ^
+                  t\.index \s*
+                    "(?<index_cols>(?:[^"\\]|\\.)*?)" \s*
+                    , \s*
+                    name\: \s* [:'"](?<name>[^"\s]+)[,"]? \s*
+                    ,? \s*
+                    (?<options>.*)
+                  $
+                  }x,
+                ->(m) {
+                  index_cols = m[:index_cols].gsub('\\"', '"')
+                  SchemaDump::Table::Index.new name: m[:name], columns: index_cols, options: eval("{" + m[:options] + "}")
+                }
+            ],
+            [ # general matching of columns
+                %r{
+                  ^
+                  t\.(?<type>\S+) \s*
+                    [:'"](?<name>[^"\s]+)[,"]? \s*
+                    ,? \s*
+                    (?<options>.*)
+                  $
+                  }x,
+                ->(m) {
+                  SchemaDump::Table::Column.new name: m[:name], type: m[:type], options: eval("{" + m[:options] + "}"), comments: []
+                }
+            ],
+            [ # index definitions with multiple columns
+                %r{
+                  ^
+                  t\.index \s*
+                    \[(?<index_cols>.*?)\] \s*
+                    , \s*
+                    name\: \s* [:'"](?<name>[^"\s]+)[,"]? \s*
+                    ,? \s*
+                    (?<options>.*)
+                  $
+                  }x,
+                ->(m) {
+                  index_cols = m[:index_cols].tr(%q{'":}, '').strip.split(/\s*,\s*/)
+                  SchemaDump::Table::Index.new name: m[:name], columns: index_cols, options: eval("{#{m[:options]}}")
+                }
+            ]
+        ].freeze
+
         def table(table, _)
           SchemaMonkey::Middleware::Dumper::Table.start(dumper: self, connection: @connection, dump: @dump, table: @dump.tables[table] = SchemaDump::Table.new(name: table)) do |env|
             stream = StringIO.new
@@ -68,34 +130,13 @@ module SchemaPlus
               env.table.trailer = m[:trailer].split("\n").map(&:strip).reject{|s| s.blank?}
               table_objects = m[:columns].strip.split("\n").map { |col|
                 cs = col.strip
-                m = cs.match %r{
-                ^
-                t\.(?<type>\S+) \s*
-                  [:'"](?<name>[^"\s]+)[,"]? \s*
-                  ,? \s*
-                  (?<options>.*)
-                $
-                }x
-                if !m.nil?
-                  SchemaDump::Table::Column.new name: m[:name], type: m[:type], options: eval("{" + m[:options] + "}"), comments: []
-                else
-                  m = cs.match %r{
-                  ^
-                  t\.index \s*
-                    \[(?<index_cols>.*?)\] \s*
-                    , \s*
-                    name\: \s* [:'"](?<name>[^"\s]+)[,"]? \s*
-                    ,? \s*
-                    (?<options>.*)
-                  $
-                  }x
-                  if m.nil?
-                    nil
-                  else
-                    index_cols = m[:index_cols].tr(%q{'":}, '').strip.split(/\s*,\s*/)
-                    SchemaDump::Table::Index.new name: m[:name], columns: index_cols, options: eval("{#{m[:options]}}")
-                  end
+                result = nil
+                # find the first regex that matches and grab the column definition
+                TABLE_COLUMN_MATCHES.find do |(r, l)|
+                  m = cs.match r
+                  result = m.nil? ? nil : l.call(m)
                 end
+                result
               }.reject { |o| o.nil? }
               env.table.columns = table_objects.select { |o| o.is_a? SchemaDump::Table::Column }
               env.table.indexes = table_objects.select { |o| o.is_a? SchemaDump::Table::Index }

data/lib/schema_plus/core/middleware.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module SchemaPlus
   module Core
     module Middleware
       module Query
         module Exec
-          ENV = [:connection, :sql, :query_name, :binds, :prepare, :result]
+          ENV = [:connection, :sql, :query_name, :binds, :options, :prepare, :result]
         end
       end
 

data/lib/schema_plus/core/schema_dump.rb

@@ -1,15 +1,20 @@
+# frozen_string_literal: true
+
 module SchemaPlus
   module Core
     class SchemaDump
       include TSort
 
-      attr_reader :initial, :tables, :dependencies, :data
-      attr_accessor :final, :trailer
+      attr_reader :initial, :extensions, :types, :tables, :dependencies, :data
+      attr_accessor :header, :final, :trailer
 
       def initialize(dumper)
         @dumper = dumper
         @dependencies = Hash.new { |h, k| h[k] = [] }
+        @header = ''
         @initial = []
+        @extensions = []
+        @types = []
         @tables = {}
         @final = []
         @data = OpenStruct.new # a place for middleware to leave data
@@ -21,7 +26,10 @@ module SchemaPlus
       end
 
       def assemble(stream)
+        stream.puts @header
         stream.puts @initial.join("\n") if initial.any?
+        stream.puts @extensions.join("\n") if extensions.any?
+        stream.puts @types.join("\n") if types.any?
         assemble_tables(stream)
         final.each do |statement|
           stream.puts "  #{statement}"
@@ -43,7 +51,8 @@ module SchemaPlus
         @dependencies[tablename].sort.uniq.reject{|t| @dumper.ignored? t}.each(&block)
       end
 
-      class Table < KeyStruct[:name, :pname, :options, :columns, :indexes, :statements, :trailer, :alt]
+      class Table < Struct.new(:name, :pname, :options, :columns, :indexes, :statements, :trailer, :alt,
+                               keyword_init: true)
         def initialize(*args)
           super
           self.columns ||= []
@@ -85,7 +94,7 @@ module SchemaPlus
           stream.puts ""
         end
 
-        class Column < KeyStruct[:name, :type, :options, :comments]
+        class Column < Struct.new(:name, :type, :options, :comments, keyword_init: true)
 
           def assemble(stream, typelen, namelen)
             stream.write "t.%-#{typelen}s " % type
@@ -102,7 +111,7 @@ module SchemaPlus
           end
         end
 
-        class Index < KeyStruct[:name, :columns, :options]
+        class Index < Struct.new(:name, :columns, :options, keyword_init: true)
 
           def assemble(stream)
             stream.write columns.inspect + ", " + {name: name}.merge(options).to_s.sub(/^{(.*)}$/, '\1')

data/lib/schema_plus/core/sql_struct.rb

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 module SchemaPlus
   module Core
     module SqlStruct
-      IndexComponents = KeyStruct[:name, :type, :columns, :options, :algorithm, :using]
+      IndexComponents = Struct.new(:name, :type, :columns, :options, :algorithm, :using, keyword_init: true)
 
-      class Table < KeyStruct[:command, :name, :body, :options, :quotechar, :inheritance]
+      class Table < Struct.new(:command, :name, :body, :options, :quotechar, :inheritance, keyword_init: true)
 
         INHERITANCE_REGEX = %r{ \s* (?<inheritance>INHERITS \s* \( [^)]* \)) }mxi
 

data/lib/schema_plus/core/version.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 module SchemaPlus
   module Core
-    VERSION = "2.2.2"
+    VERSION = "3.1.0.beta.3"
   end
 end

data/lib/schema_plus/core.rb

@@ -1,5 +1,7 @@
+# frozen_string_literal: true
+
 require "schema_monkey"
-require 'its-it'
+require 'active_support/core_ext/array/wrap'
 require "pathname"
 
 module SchemaPlus
@@ -26,8 +28,6 @@ require_relative "core/schema_dump"
 require_relative "core/sql_struct"
 require_relative "core/version"
 
-if ActiveRecord.version >= Gem::Version.new('5.2')
-  require_relative "core/active_record/connection_adapters/postgresql/schema_dumper"
-end
+require_relative "core/active_record/connection_adapters/postgresql/schema_dumper"
 
 SchemaMonkey.register(SchemaPlus::Core)

data/schema_dev.yml

@@ -1,11 +1,14 @@
 ruby:
-    - 2.4.4
-    - 2.5.1
+    - 2.5
+    - 2.7
+    - 3.0
+    - 3.1
 activerecord:
-    - 5.0
-    - 5.1
     - 5.2
+    - 6.0
+    - 6.1
+    - 7.0
 db:
+    - postgresql
     - mysql2
     - sqlite3
-    - postgresql

data/schema_plus_core.gemspec

@@ -1,4 +1,5 @@
-# coding: utf-8
+# frozen_string_literal: true
+
 lib = File.expand_path('../lib', __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'schema_plus/core/version'
@@ -18,16 +19,14 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_dependency "activerecord", "~> 5.0"
-  gem.add_dependency "schema_monkey", "~> 2.1"
-  gem.add_dependency "its-it", "~> 1.2"
+  gem.required_ruby_version = ">= 2.5.0"
+
+  gem.add_dependency "activerecord", ">= 5.2", "< 7.1"
+  gem.add_dependency "schema_monkey", "~> 3.0.2.beta.1"
 
-  gem.add_development_dependency "bundler", "~> 1.7"
-  gem.add_development_dependency "rake", "~> 10.0"
+  gem.add_development_dependency "bundler"
+  gem.add_development_dependency "rake", "~> 13.0.0"
   gem.add_development_dependency "rspec", "~> 3.0"
   gem.add_development_dependency "rspec-given"
-  gem.add_development_dependency "schema_dev", "~> 3.11"
-  gem.add_development_dependency "simplecov"
-  gem.add_development_dependency "simplecov-gem-profile"
-  gem.add_development_dependency "its-it"
+  gem.add_development_dependency "schema_dev", "~> 4.2.beta.1"
 end

data/spec/column_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 module TestImplementsReference
@@ -27,8 +29,7 @@ describe SchemaMonkey::Middleware::Migration::Column do
     let (:spy) { described_class.const_get(:SPY) }
 
     let (:pk_type) do
-      if ActiveRecord.version >= Gem::Version.new('5.1') &&
-         ActiveRecord::Base.connection.adapter_name =~ /mysql|postgresql/i
+      if ActiveRecord::Base.connection.adapter_name =~ /mysql|postgresql/i
         :bigint
       else
         :integer