pg_saurus 3.5.0 → 3.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: b29ece12fe51ab68cec6a95570a9bd372aff0d2f
-  data.tar.gz: 0ba27c826028135791fcd45f8f742ea650cd3042
+SHA256:
+  metadata.gz: a04193fb420ad671f1ee5a9a43a051ff6bbeeddde6dbd2f113cf6c4eff1dbfc8
+  data.tar.gz: 4433591bdb134a720112d186eaf78f96547054862ef56ffb3aa7f1f6622a211a
 SHA512:
-  metadata.gz: 4ce85db15d409ee8ccac7fd7d3315a6bdbb6a721d6df1aff5df23a490d1d1a8bebf8383913b822dd7e724c57ddb424d699032baa723ece99e41078652248342a
-  data.tar.gz: ebbc2881e0153ecaea674d28a78aa6f59106a41059db4caf26748a092b7edcdb35324ed4ef8618ede82cbf30fd5b73f7cc31919f905edf37b7fb3260c7b967ef
+  metadata.gz: 365019237474f3eaf8084a5bce6ad12ed641f80fd1a931a36beca0694813a965d708fc86e9e36e7038e8ea02ba9a4706a3b66f3012fffefe137b0b692ddf32b5
+  data.tar.gz: 0b917b79f68c042dbfe6c47539c58e48a1d0b13f6017602280cf8ef0ff73ed80549658ef137934751225d22e322ed4230f09a719509c36168a4b526dbcec6cea

data/lib/core_ext/active_record/connection_adapters/abstract/schema_statements.rb

@@ -1,184 +1,186 @@
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
-    module SchemaStatements # :nodoc:
-      # Regexp used to find the function name and function argument of a
-      # function call:
-      FUNCTIONAL_INDEX_REGEXP = /(\w+)\(((?:'.+'(?:::\w+)?, *)*)(\w+)\)/
-
-      # Regexp used to find the operator name (or operator string, e.g. "DESC NULLS LAST"):
-      OPERATOR_REGEXP = /(.+?)\s([\w\s]+)$/
-
-      # Redefine original add_index method to handle :concurrently option.
-      #
-      # Adds a new index to the table.  +column_name+ can be a single Symbol, or
-      # an Array of Symbols.
-      #
-      # ====== Creating a partial index
-      #  add_index(:accounts, [:branch_id, :party_id], :using => 'BTree'
-      #   :unique => true, :concurrently => true, :where => 'active')
-      # generates
-      #  CREATE UNIQUE INDEX CONCURRENTLY
-      #   index_accounts_on_branch_id_and_party_id
-      #  ON
-      #    accounts(branch_id, party_id)
-      #  WHERE
-      #    active
-      #
-      def add_index_with_concurrently(table_name, column_name, options = {})
-        creation_method = options.delete(:concurrently) ? 'CONCURRENTLY' : nil
-
-        # Whether to skip the quoting of columns. Used only for expressions like JSON indexes in which
-        # the column is difficult to target for quoting.
-        skip_column_quoting = options.delete(:skip_column_quoting) or false
-
-        index_name,
-        index_type,
-        index_columns,
-        index_options,
-        index_algorithm,
-        index_using      = add_index_options(table_name, column_name, options)
-
-        # GOTCHA:
-        #   It ensures that there is no existing index only for the case when the index
-        #   is created concurrently to avoid changing the error behavior for default
-        #   index creation.
-        #   -- zekefast 2012-09-25
-        # GOTCHA:
-        #   This check prevents invalid index creation, so after migration failed
-        #   here there is no need to go to database and clean it from invalid
-        #   indexes. But note that this handles only one of the cases when index
-        #   creation can fail!!! All other case should be procesed manually.
-        #   -- zekefast 2012-09-25
-        if creation_method.present? && index_exists?(table_name, column_name, options)
-          raise ::PgSaurus::IndexExistsError,
-                "Index #{index_name} for `#{table_name}.#{column_name}` " \
-                "column can not be created concurrently, because such index already exists."
-        end
+    module PostgreSQL # :nodoc:
+      module SchemaStatements # :nodoc:
+        # Regexp used to find the function name and function argument of a
+        # function call:
+        FUNCTIONAL_INDEX_REGEXP = /(\w+)\(((?:'.+'(?:::\w+)?, *)*)(\w+)\)/
+
+        # Regexp used to find the operator name (or operator string, e.g. "DESC NULLS LAST"):
+        OPERATOR_REGEXP = /(.+?)\s([\w\s]+)$/
+
+        # Redefine original add_index method to handle :concurrently option.
+        #
+        # Adds a new index to the table.  +column_name+ can be a single Symbol, or
+        # an Array of Symbols.
+        #
+        # ====== Creating a partial index
+        #  add_index(:accounts, [:branch_id, :party_id], :using => 'BTree'
+        #   :unique => true, :concurrently => true, :where => 'active')
+        # generates
+        #  CREATE UNIQUE INDEX CONCURRENTLY
+        #   index_accounts_on_branch_id_and_party_id
+        #  ON
+        #    accounts(branch_id, party_id)
+        #  WHERE
+        #    active
+        #
+        def add_index(table_name, column_name, options = {})
+          creation_method = options.delete(:concurrently) ? 'CONCURRENTLY' : nil
+
+          # Whether to skip the quoting of columns. Used only for expressions like JSON indexes in which
+          # the column is difficult to target for quoting.
+          skip_column_quoting = options.delete(:skip_column_quoting) or false
+
+          index_name,
+          index_type,
+          index_columns,
+          index_options,
+          index_algorithm,
+          index_using      = add_index_options(table_name, column_name, options)
+
+          # GOTCHA:
+          #   It ensures that there is no existing index only for the case when the index
+          #   is created concurrently to avoid changing the error behavior for default
+          #   index creation.
+          #   -- zekefast 2012-09-25
+          # GOTCHA:
+          #   This check prevents invalid index creation, so after migration failed
+          #   here there is no need to go to database and clean it from invalid
+          #   indexes. But note that this handles only one of the cases when index
+          #   creation can fail!!! All other case should be procesed manually.
+          #   -- zekefast 2012-09-25
+          if creation_method.present? && index_exists?(table_name, column_name, options)
+            raise ::PgSaurus::IndexExistsError,
+                  "Index #{index_name} for `#{table_name}.#{column_name}` " \
+                  "column can not be created concurrently, because such index already exists."
+          end
 
-        statements = []
-        statements << "CREATE #{index_type} INDEX"
-        statements << creation_method      if creation_method.present?
-        statements << index_algorithm      if index_algorithm.present?
-        statements << quote_column_name(index_name)
-        statements << "ON"
-        statements << quote_table_name(table_name)
-        statements << index_using          if index_using.present?
-        statements << "(#{index_columns})" if index_columns.present? unless skip_column_quoting
-        statements << "(#{column_name})"   if column_name.present? and skip_column_quoting
-        statements << index_options        if index_options.present?
-
-        sql = statements.join(' ')
-        execute(sql)
-      end
+          statements = []
+          statements << "CREATE #{index_type} INDEX"
+          statements << creation_method      if creation_method.present?
+          statements << index_algorithm      if index_algorithm.present?
+          statements << quote_column_name(index_name)
+          statements << "ON"
+          statements << quote_table_name(table_name)
+          statements << index_using          if index_using.present?
+          statements << "(#{index_columns})" if index_columns.present? unless skip_column_quoting
+          statements << "(#{column_name})"   if column_name.present? and skip_column_quoting
+          statements << index_options        if index_options.present?
+
+          sql = statements.join(' ')
+          execute(sql)
+        end
 
-      # Check to see if an index exists on a table for a given index definition.
-      #
-      # === Examples
-      #  # Check that a partial index exists
-      #  index_exists?(:suppliers, :company_id, :where => 'active')
-      #
-      #  # GIVEN: 'index_suppliers_on_company_id' UNIQUE, btree (company_id) WHERE active
-      #  index_exists?(:suppliers, :company_id, :unique => true, :where => 'active') => true
-      #  index_exists?(:suppliers, :company_id, :unique => true) => false
-      #
-      def index_exists?(table_name, column_name, options = {})
-        column_names = Array.wrap(column_name)
-        index_name = options.key?(:name) ? options[:name].to_s : index_name(table_name, :column => column_names)
-
-        # Always compare the index name
-        default_comparator = lambda { |index| index.name == index_name }
-        comparators = [default_comparator]
-
-        # Add a comparator for each index option that is part of the query
-        index_options = [:unique, :where]
-        index_options.each do |index_option|
-          comparators << if options.key?(index_option)
-            lambda do |index|
-              pg_where_clause = index.send(index_option)
-              # pg does nothing to boolean clauses, e.g. 'where active' => 'where active'
-              if pg_where_clause.is_a?(TrueClass) or pg_where_clause.is_a?(FalseClass)
-                pg_where_clause == options[index_option]
-              else
-                # pg adds parentheses around non-boolean clauses, e.g. 'where color IS NULL' => 'where (color is NULL)'
-                pg_where_clause.gsub!(/[()]/,'')
-                # pg casts string comparison ::text. e.g. "where color = 'black'" => "where ((color)::text = 'black'::text)"
-                pg_where_clause.gsub!(/::text/,'')
-                # prevent case from impacting the comparison
-                pg_where_clause.downcase == options[index_option].downcase
+        # Check to see if an index exists on a table for a given index definition.
+        #
+        # === Examples
+        #  # Check that a partial index exists
+        #  index_exists?(:suppliers, :company_id, :where => 'active')
+        #
+        #  # GIVEN: 'index_suppliers_on_company_id' UNIQUE, btree (company_id) WHERE active
+        #  index_exists?(:suppliers, :company_id, :unique => true, :where => 'active') => true
+        #  index_exists?(:suppliers, :company_id, :unique => true) => false
+        #
+        def index_exists?(table_name, column_name, options = {})
+          column_names = Array.wrap(column_name)
+          index_name = options.key?(:name) ? options[:name].to_s : index_name(table_name, :column => column_names)
+
+          # Always compare the index name
+          default_comparator = lambda { |index| index.name == index_name }
+          comparators = [default_comparator]
+
+          # Add a comparator for each index option that is part of the query
+          index_options = [:unique, :where]
+          index_options.each do |index_option|
+            comparators << if options.key?(index_option)
+              lambda do |index|
+                pg_where_clause = index.send(index_option)
+                # pg does nothing to boolean clauses, e.g. 'where active' => 'where active'
+                if pg_where_clause.is_a?(TrueClass) or pg_where_clause.is_a?(FalseClass)
+                  pg_where_clause == options[index_option]
+                else
+                  # pg adds parentheses around non-boolean clauses, e.g. 'where color IS NULL' => 'where (color is NULL)'
+                  pg_where_clause.gsub!(/[()]/,'')
+                  # pg casts string comparison ::text. e.g. "where color = 'black'" => "where ((color)::text = 'black'::text)"
+                  pg_where_clause.gsub!(/::text/,'')
+                  # prevent case from impacting the comparison
+                  pg_where_clause.downcase == options[index_option].downcase
+                end
               end
+            else
+              # If the given index_option is not an argument to the index_exists? query,
+              # select only those pg indexes that do not have the component
+              lambda { |index| index.send(index_option).blank? }
             end
-          else
-            # If the given index_option is not an argument to the index_exists? query,
-            # select only those pg indexes that do not have the component
-            lambda { |index| index.send(index_option).blank? }
           end
-        end
 
-        # Search all indexes for any that match all comparators
-        indexes(table_name).any? do |index|
-          comparators.inject(true) { |ret, comparator| ret && comparator.call(index) }
+          # Search all indexes for any that match all comparators
+          indexes(table_name).any? do |index|
+            comparators.inject(true) { |ret, comparator| ret && comparator.call(index) }
+          end
         end
-      end
 
-      # Derive the name of the index from the given table name and options hash.
-      def index_name(table_name, options) #:nodoc:
-        if Hash === options # legacy support
-          if options[:column]
-            column_names = Array.wrap(options[:column]).map {|c| expression_index_name(c)}
-            "index_#{table_name}_on_#{column_names * '_and_'}"
-          elsif options[:name]
-            options[:name]
+        # Derive the name of the index from the given table name and options hash.
+        def index_name(table_name, options) #:nodoc:
+          if Hash === options # legacy support
+            if options[:column]
+              column_names = Array.wrap(options[:column]).map {|c| expression_index_name(c)}
+              "index_#{table_name}_on_#{column_names * '_and_'}"
+            elsif options[:name]
+              options[:name]
+            else
+              raise ArgumentError, "You must specify the index name"
+            end
           else
-            raise ArgumentError, "You must specify the index name"
+            index_name(table_name, :column => options)
           end
-        else
-          index_name(table_name, :column => options)
         end
-      end
 
-      # Override super method to provide support for expression column names.
-      def quoted_columns_for_index(column_names, options = {})
-        column_names.map do |name|
+        # Override super method to provide support for expression column names.
+        def quoted_columns_for_index(column_names, options = {})
+          column_names.map do |name|
+            column_name, operator_name = split_column_name(name)
+
+            result_name = if column_name =~ FUNCTIONAL_INDEX_REGEXP
+                            "#{$1}(#{$2}#{quote_column_name($3)})"
+                          else
+                            quote_column_name(column_name)
+                          end
+
+            result_name += " " + operator_name if operator_name
+
+            result_name
+          end
+        end
+        protected :quoted_columns_for_index
+
+        # Map an expression to a name appropriate for an index.
+        def expression_index_name(name)
           column_name, operator_name = split_column_name(name)
 
           result_name = if column_name =~ FUNCTIONAL_INDEX_REGEXP
-                          "#{$1}(#{$2}#{quote_column_name($3)})"
+                          "#{$1.downcase}_#{$3}"
                         else
-                          quote_column_name(column_name)
+                          column_name
                         end
 
-          result_name += " " + operator_name if operator_name
+          result_name += "_" + operator_name.parameterize.underscore if operator_name
 
           result_name
         end
-      end
-      protected :quoted_columns_for_index
-
-      # Map an expression to a name appropriate for an index.
-      def expression_index_name(name)
-        column_name, operator_name = split_column_name(name)
+        private :expression_index_name
 
-        result_name = if column_name =~ FUNCTIONAL_INDEX_REGEXP
-                        "#{$1.downcase}_#{$3}"
-                      else
-                        column_name
-                      end
-
-        result_name += "_" + operator_name.parameterize.underscore if operator_name
-
-        result_name
-      end
-      private :expression_index_name
-
-      # Split column name to name and operator class if possible.
-      def split_column_name(name)
-        if name =~ OPERATOR_REGEXP
-          return $1, $2
-        else
-          return name, nil
+        # Split column name to name and operator class if possible.
+        def split_column_name(name)
+          if name =~ OPERATOR_REGEXP
+            return $1, $2
+          else
+            return name, nil
+          end
         end
+        private :split_column_name
       end
-      private :split_column_name
     end
   end
 end

data/lib/pg_saurus/connection_adapters/abstract_adapter.rb

@@ -1,7 +1,6 @@
 # Extends ActiveRecord::ConnectionAdapters::AbstractAdapter class.
 module PgSaurus::ConnectionAdapters::AbstractAdapter
   extend ActiveSupport::Autoload
-  extend ActiveSupport::Concern
 
   autoload :CommentMethods
   autoload :SchemaMethods
@@ -14,9 +13,4 @@ module PgSaurus::ConnectionAdapters::AbstractAdapter
   include IndexMethods
   include FunctionMethods
   include TriggerMethods
-
-  included do
-    alias_method_chain :create_table, :schema_option
-    alias_method_chain :drop_table  , :schema_option
-  end
 end

data/lib/pg_saurus/connection_adapters/abstract_adapter/schema_methods.rb

@@ -3,18 +3,18 @@
 module PgSaurus::ConnectionAdapters::AbstractAdapter::SchemaMethods
 
   # Provide :schema option to +create_table+ method.
-  def create_table_with_schema_option(table_name, options = {}, &block)
+  def create_table(table_name, options = {}, &block)
     options     = options.dup
     schema_name = options.delete(:schema)
     table_name  = "#{schema_name}.#{table_name}" if schema_name
-    create_table_without_schema_option(table_name, options, &block)
+    super(table_name, options, &block)
   end
 
   # Provide :schema option to +drop_table+ method.
-  def drop_table_with_schema_option(table_name, options = {})
+  def drop_table(table_name, options = {})
     options     = options.dup
     schema_name = options.delete(:schema)
     table_name  = "#{schema_name}.#{table_name}" if schema_name
-    drop_table_without_schema_option(table_name, options)
+    super(table_name, options)
   end
 end

data/lib/pg_saurus/connection_adapters/postgresql_adapter.rb

@@ -26,16 +26,6 @@ module PgSaurus::ConnectionAdapters::PostgreSQLAdapter
   include TriggerMethods
 
   included do
-    alias_method_chain :tables, :non_public_schema_tables
-    alias_method_chain :add_index, :concurrently
-    alias_method_chain :drop_table, :schema_option
-    alias_method_chain :rename_table, :schema_option
-
-    alias_method_chain :add_foreign_key, :index
-    alias_method_chain :remove_foreign_key, :index
-    alias_method_chain :foreign_key_column_for, :schema
-    alias_method_chain :foreign_keys, :schema
-
     ::ActiveRecord::ConnectionAdapters::ForeignKeyDefinition.module_eval do
       def from_schema
         options[:from_schema] || 'public'

data/lib/pg_saurus/connection_adapters/postgresql_adapter/foreign_key_methods.rb

@@ -24,7 +24,7 @@ module PgSaurus # :nodoc:
     # See activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
     # Creates index on the FK column by default. Pass in the option :exclude_index => true
     # to disable this.
-    def add_foreign_key_with_index(from_table, to_table, options = {})
+    def add_foreign_key(from_table, to_table, options = {})
       exclude_index = (options.has_key?(:exclude_index) ? options.delete(:exclude_index) : false)
       column        = options[:column] || foreign_key_column_for(to_table)
 
@@ -34,7 +34,7 @@ module PgSaurus # :nodoc:
           "  Use :exclude_index => true when adding the foreign key."
       end
 
-      add_foreign_key_without_index from_table, to_table, options
+      super from_table, to_table, options
 
       unless exclude_index
         add_index from_table, column
@@ -42,24 +42,24 @@ module PgSaurus # :nodoc:
     end
 
     # See activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
-    def remove_foreign_key_with_index(from_table, options_or_to_table = {})
+    def remove_foreign_key(from_table, options_or_to_table = {})
       if options_or_to_table.is_a?(Hash) && options_or_to_table[:remove_index]
         column = options_or_to_table[:column]
         remove_index from_table, column
       end
 
-      remove_foreign_key_without_index(from_table, options_or_to_table)
+      super(from_table, options_or_to_table)
     end
 
     # See: activerecord/lib/active_record/connection_adapters/abstract/schema_statements.rb
-    def foreign_key_column_for_with_schema(table_name)
+    def foreign_key_column_for(table_name)
       table = table_name.to_s.split('.').last
 
-      foreign_key_column_for_without_schema table
+      super table
     end
 
     # see activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb
-    def foreign_keys_with_schema(table_name)
+    def foreign_keys(table_name)
       namespace  = table_name.to_s.split('.').first
       table_name = table_name.to_s.split('.').last
 

data/lib/pg_saurus/connection_adapters/postgresql_adapter/schema_methods.rb

@@ -35,11 +35,11 @@ module PgSaurus::ConnectionAdapters::PostgreSQLAdapter::SchemaMethods
   end
 
   # Provide :schema option to +drop_table+ method.
-  def drop_table_with_schema_option(table_name, options = {})
+  def drop_table(table_name, options = {})
     options     = options.dup
     schema_name = options.delete(:schema)
     table_name  = "#{schema_name}.#{table_name}" if schema_name
-    drop_table_without_schema_option(table_name, options)
+    super(table_name, options)
   end
 
   # Make method +tables+ return tables not only from public schema.
@@ -51,8 +51,8 @@ module PgSaurus::ConnectionAdapters::PostgreSQLAdapter::SchemaMethods
   #   See: https://github.com/TMXCredit/pg_power/pull/42
   #
   # @return [Array<String>] table names
-  def tables_with_non_public_schema_tables(*args)
-    public_tables = tables_without_non_public_schema_tables(*args)
+  def tables(*args)
+    public_tables = super(*args)
 
     non_public_tables =
       query(<<-SQL, 'SCHEMA').map { |row| row[0] }
@@ -65,14 +65,14 @@ module PgSaurus::ConnectionAdapters::PostgreSQLAdapter::SchemaMethods
   end
 
   # Provide :schema option to +rename_table+ method.
-  def rename_table_with_schema_option(table_name, new_name, options = {})
+  def rename_table(table_name, new_name, options = {})
     schema_name = options[:schema]
     if schema_name
       in_schema schema_name do
-        rename_table_without_schema_option(table_name, new_name)
+        super(table_name, new_name)
       end
     else
-      rename_table_without_schema_option(table_name, new_name)
+      super(table_name, new_name)
     end
   end
 

data/lib/pg_saurus/create_index_concurrently.rb

@@ -146,20 +146,13 @@ module PgSaurus::CreateIndexConcurrently
   # @see ::ActiveRecord::Migrator.migrate
   # @see ::ActiveRecord::Migrator.ddl_transaction
   module Migrator
-    extend ActiveSupport::Concern
-
-    # :nodoc:
-    def self.included(klass)
-      klass.alias_method_chain :ddl_transaction, :postponed_queries
-    end
-
     # Override (see ::ActiveRecord::Migrator.ddl_transaction) to call
     # (see ::PgSaurus::CreateIndexConcurrently::Migration.process_postponed_queries)
     # immediately after transaction.
     #
     # @see ::ActiveRecord::Migrator.ddl_transaction
-    def ddl_transaction_with_postponed_queries(*args, &block)
-      ddl_transaction_without_postponed_queries(*args, &block)
+    def ddl_transaction(*args, &block)
+      super(*args, &block)
 
       # GOTCHA:
       #   This might be a bit tricky, but I've decided that this is the best

data/lib/pg_saurus/engine.rb

@@ -12,9 +12,20 @@ module PgSaurus
           require ::PgSaurus::Engine.root + 'lib/core_ext/active_record/' + path
         end
 
-        ActiveRecord::SchemaDumper.class_eval { include ::PgSaurus::SchemaDumper }
+        ActiveRecord::SchemaDumper.class_eval do
+          prepend ::PgSaurus::SchemaDumper::SchemaMethods
+          prepend ::PgSaurus::SchemaDumper::ExtensionMethods
+          prepend ::PgSaurus::SchemaDumper::ViewMethods
+          prepend ::PgSaurus::SchemaDumper::FunctionMethods
+          prepend ::PgSaurus::SchemaDumper::CommentMethods
+          prepend ::PgSaurus::SchemaDumper::TriggerMethods
+          prepend ::PgSaurus::SchemaDumper::ForeignKeyMethods
+
+          include ::PgSaurus::SchemaDumper
+        end
 
         ActiveRecord::Migration.class_eval do
+          prepend ::PgSaurus::Migration::SetRoleMethod::Extension
           include ::PgSaurus::Migration::SetRoleMethod
         end
 
@@ -30,7 +41,7 @@ module PgSaurus
           include ::PgSaurus::CreateIndexConcurrently::Migration
         end
         ActiveRecord::Migrator.class_eval do
-          include ::PgSaurus::CreateIndexConcurrently::Migrator
+          prepend PgSaurus::CreateIndexConcurrently::Migrator
         end
         ActiveRecord::MigrationProxy.class_eval do
           include ::PgSaurus::CreateIndexConcurrently::MigrationProxy
@@ -41,6 +52,7 @@ module PgSaurus
         end
 
         ActiveRecord::ConnectionAdapters::AbstractAdapter.module_eval do
+          prepend ::PgSaurus::ConnectionAdapters::AbstractAdapter::SchemaMethods
           include ::PgSaurus::ConnectionAdapters::AbstractAdapter
         end
 
@@ -51,6 +63,9 @@ module PgSaurus
         end
 
         sql_adapter_class.class_eval do
+          prepend ::PgSaurus::ConnectionAdapters::PostgreSQLAdapter::SchemaMethods
+          prepend ::PgSaurus::ConnectionAdapters::PostgreSQLAdapter::ForeignKeyMethods
+
           include ::PgSaurus::ConnectionAdapters::PostgreSQLAdapter
         end
 

data/lib/pg_saurus/migration/set_role_method.rb

@@ -28,8 +28,6 @@ module PgSaurus
           @keep_default_role
         end
       end
-
-      alias_method_chain :exec_migration, :role
     end
 
     # Get role
@@ -42,33 +40,37 @@ module PgSaurus
       self.class.keep_default_role?
     end
 
-    # Wrap original `exec_migration` to run migration with set role.
-    #
-    # @param conn [ActiveRecord::ConnectionAdapters::PostgreSQLAdapter]
-    # @param direction [Symbol] :up or :down
-    #
-    # @return [void]
-    def exec_migration_with_role(conn, direction)
-      if role
-        begin
-          conn.execute "SET ROLE #{role}"
-          exec_migration_without_role(conn, direction)
-        ensure
-          conn.execute "RESET ROLE"
+    # Module to be prepended into ActiveRecord::Migration which allows
+    # enhancing the exec_migration method.
+    module Extension
+      # Wrap original `exec_migration` to run migration with set role.
+      #
+      # @param conn [ActiveRecord::ConnectionAdapters::PostgreSQLAdapter]
+      # @param direction [Symbol] :up or :down
+      #
+      # @return [void]
+      def exec_migration(conn, direction)
+        if role
+          begin
+            conn.execute "SET ROLE #{role}"
+            super(conn, direction)
+          ensure
+            conn.execute "RESET ROLE"
+          end
+        elsif PgSaurus.config.ensure_role_set && !keep_default_role?
+          msg =
+            "Role for migration #{self.class} is not set\n\n" \
+            "You've configured PgSaurus with ensure_role_set=true. \n" \
+            "That means that every migration must explicitly set role with set_role method.\n\n" \
+            "Example:\n" \
+            "  class CreateNewTable < ActiveRecord::Migration\n" \
+            "    set_role \"superhero\"\n" \
+            "  end\n\n" \
+            "If you want to set ensure_role_set=false, take a look at config/initializers/pg_saurus.rb\n\n"
+          raise PgSaurus::RoleNotSetError, msg
+        else
+          super(conn, direction)
         end
-      elsif PgSaurus.config.ensure_role_set && !keep_default_role?
-        msg =
-          "Role for migration #{self.class} is not set\n\n" \
-          "You've configured PgSaurus with ensure_role_set=true. \n" \
-          "That means that every migration must explicitly set role with set_role method.\n\n" \
-          "Example:\n" \
-          "  class CreateNewTable < ActiveRecord::Migration\n" \
-          "    set_role \"superhero\"\n" \
-          "  end\n\n" \
-          "If you want to set ensure_role_set=false, take a look at config/initializers/pg_saurus.rb\n\n"
-        raise PgSaurus::RoleNotSetError, msg
-      else
-        exec_migration_without_role(conn, direction)
       end
     end
 

data/lib/pg_saurus/schema_dumper.rb

@@ -3,7 +3,6 @@
 # and tables.
 module PgSaurus::SchemaDumper
   extend ActiveSupport::Autoload
-  extend ActiveSupport::Concern
 
   autoload :ExtensionMethods
   autoload :CommentMethods
@@ -20,16 +19,4 @@ module PgSaurus::SchemaDumper
   include ViewMethods
   include FunctionMethods
   include TriggerMethods
-
-  included do
-    alias_method_chain :header, :schemas
-    alias_method_chain :header, :extensions
-
-    alias_method_chain :tables, :views
-    alias_method_chain :tables, :functions
-    alias_method_chain :tables, :triggers
-    alias_method_chain :tables, :comments
-
-    alias_method_chain :foreign_keys, :indexes
-  end
 end

data/lib/pg_saurus/schema_dumper/comment_methods.rb

@@ -2,8 +2,8 @@
 module PgSaurus::SchemaDumper::CommentMethods
   # Hook ActiveRecord::SchemaDumper#table method to dump comments on
   # table and columns.
-  def tables_with_comments(stream)
-    tables_without_comments(stream)
+  def tables(stream)
+    super(stream)
 
     # Dump table and column comments
     @connection.tables.sort.each do |table_name|

data/lib/pg_saurus/schema_dumper/extension_methods.rb

@@ -2,8 +2,8 @@
 module PgSaurus::SchemaDumper::ExtensionMethods
   # Hook ActiveRecord::SchemaDumper#header method to dump extensions in all
   # schemas except for pg_catalog.
-  def header_with_extensions(stream)
-    header_without_extensions(stream)
+  def header(stream)
+    super(stream)
     dump_extensions(stream)
     stream
   end

data/lib/pg_saurus/schema_dumper/foreign_key_methods.rb

@@ -3,7 +3,7 @@
 module PgSaurus::SchemaDumper::ForeignKeyMethods
 
   # See activerecord/lib/active_record/schema_dumper.rb
-  def foreign_keys_with_indexes(table, stream)
+  def foreign_keys(table, stream)
     if (foreign_keys = @connection.foreign_keys(table)).any?
       add_foreign_key_statements = foreign_keys.map do |foreign_key|
 

data/lib/pg_saurus/schema_dumper/function_methods.rb

@@ -2,12 +2,12 @@
 module PgSaurus::SchemaDumper::FunctionMethods
 
   # :nodoc
-  def tables_with_functions(stream)
+  def tables(stream)
     # Functions must be dumped before tables.
     # Some indexes may use defined functions.
     dump_functions stream
 
-    tables_without_functions(stream)
+    super(stream)
 
     stream
   end

data/lib/pg_saurus/schema_dumper/schema_methods.rb

@@ -2,8 +2,8 @@
 # and tables from those schemas.
 module PgSaurus::SchemaDumper::SchemaMethods
   # Dump create schema statements
-  def header_with_schemas(stream)
-    header_without_schemas(stream)
+  def header(stream)
+    super(stream)
     schemas(stream)
     stream
   end

data/lib/pg_saurus/schema_dumper/trigger_methods.rb

@@ -2,8 +2,8 @@
 module PgSaurus::SchemaDumper::TriggerMethods
 
   # :nodoc
-  def tables_with_triggers(stream)
-    tables_without_triggers(stream)
+  def tables(stream)
+    super(stream)
 
     dump_triggers(stream)
     stream.puts

data/lib/pg_saurus/schema_dumper/view_methods.rb

@@ -1,8 +1,8 @@
 # Extends ActiveRecord::SchemaDumper class to dump views
 module PgSaurus::SchemaDumper::ViewMethods
   # Dump create view statements
-  def tables_with_views(stream)
-    tables_without_views(stream)
+  def tables(stream)
+    super(stream)
     views(stream)
     stream
   end

data/lib/pg_saurus/version.rb

@@ -1,4 +1,4 @@
 module PgSaurus
   # Version of pg_saurus gem.
-  VERSION = "3.5.0"
+  VERSION = "3.6.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pg_saurus
 version: !ruby/object:Gem::Version
-  version: 3.5.0
+  version: 3.6.0
 platform: ruby
 authors:
 - Potapov Sergey
@@ -13,7 +13,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-10 00:00:00.000000000 Z
+date: 2019-07-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pg
@@ -273,7 +273,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 2.7.9
 signing_key: 
 specification_version: 4
 summary: ActiveRecord extensions for PostgreSQL.