torque-postgresql 1.1.0 → 1.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: a161d5be06adc9e93a5888b4b16b1a07b6f4a613
-  data.tar.gz: 51c1aae61c09bfa681e02daeb523551da9ef1139
+SHA256:
+  metadata.gz: 91a42a9a04ba195e57f4b87af2931a6ecf82e9d58a4acec84b95350404ee4977
+  data.tar.gz: e4fce1b312a40bf6e98a1f8bee8351795a45a5afddf25ce0f7765cd6c01d89ec
 SHA512:
-  metadata.gz: 99892a8ca40bf830e81accb0d4f15d87fbcb44697b95b4f9854a81b2e5d733c80c1a23f7312009407741ea11e7a6cb4d29acae8b03284226d618fadfbaa6a9da
-  data.tar.gz: 53e5888be0f1c89d2e30c85acc2ad350e34ad5efe6b6d899315a4cd18affe9366978d5cfd7e4ddad7843c0856ca11f7243f106d5d4ad2f538a86e2c11d5551ce
+  metadata.gz: 56a370889f5ffbb09a2c414bd1a9c4311d4d415675fd8ac7f00a09ffb4b2aa4b70998b475f6ab494ad06f0e0b9783ddea599268f04d0c5d3184b9e1d0d644d44
+  data.tar.gz: 7341f28b3805af398868be6a4095c9dcf4b9e7d6be28a0ce4e2af0340004490e2e75b9eb6e7e63f9d6ac0bba1caf5fdb7154cd5b8d7928c6c093f748cda96d71

data/Rakefile

@@ -14,13 +14,16 @@ RDoc::Task.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-desc 'Prints a schema dump of the test database'
-task :dump do |t|
+desc 'Initialize the local environment'
+task :environment do |t|
   lib  = File.expand_path('../lib', __FILE__)
   spec = File.expand_path('../spec', __FILE__)
   $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
   $LOAD_PATH.unshift(spec) unless $LOAD_PATH.include?(spec)
+end
 
+desc 'Prints a schema dump of the test database'
+task dump: :environment do |t|
   require 'byebug'
   require 'spec_helper'
   ActiveRecord::SchemaDumper.dump

data/lib/torque/postgresql/attributes.rb

@@ -4,19 +4,3 @@ require_relative 'attributes/builder'
 require_relative 'attributes/enum'
 require_relative 'attributes/enum_set'
 require_relative 'attributes/period'
-
-module Torque
-  module PostgreSQL
-    module Attributes
-      extend ActiveSupport::Concern
-
-      # Configure enum_save_on_bang behavior
-      included do
-        class_attribute :enum_save_on_bang, instance_accessor: true
-        self.enum_save_on_bang = Torque::PostgreSQL.config.enum.save_on_bang
-      end
-    end
-
-    ActiveRecord::Base.include Attributes
-  end
-end

data/lib/torque/postgresql/attributes/builder.rb

@@ -5,14 +5,14 @@ module Torque
   module PostgreSQL
     module Attributes
       module Builder
-        def self.include_on(klass, method_name, builder_klass, &block)
+        def self.include_on(klass, method_name, builder_klass, **extra, &block)
           klass.define_singleton_method(method_name) do |*args, **options|
             return unless connection.table_exists?(table_name)
 
             args.each do |attribute|
               begin
                 # Generate methods on self class
-                builder = builder_klass.new(self, attribute, options)
+                builder = builder_klass.new(self, attribute, extra.merge(options))
                 builder.conflicting?
                 builder.build
 

data/lib/torque/postgresql/attributes/builder/enum.rb

@@ -5,7 +5,8 @@ module Torque
         class Enum
           VALID_TYPES = %i[enum enum_set].freeze
 
-          attr_accessor :klass, :attribute, :subtype, :options, :values, :enum_module
+          attr_accessor :klass, :attribute, :subtype, :options, :values,
+            :klass_module, :instance_module
 
           # Start a new builder of methods for enum values on ActiveRecord::Base
           def initialize(klass, attribute, options)
@@ -40,15 +41,20 @@ module Torque
 
             @values_methods = begin
               values.map do |val|
-                val   = val.tr('-', '_')
-                scope = base % val
+                key   = val.downcase.tr('- ', '__')
+                scope = base % key
                 ask   = scope + '?'
                 bang  = scope + '!'
-                [val, [scope, ask, bang]]
+                [key, [scope, ask, bang, val]]
               end.to_h
             end
           end
 
+          # Check if it's building the methods for sets
+          def set_features?
+            options[:set_features].present?
+          end
+
           # Check if any of the methods that will be created get in conflict
           # with the base class methods
           def conflicting?
@@ -56,12 +62,20 @@ module Torque
             attributes = attribute.pluralize
 
             dangerous?(attributes, true)
-            dangerous?("#{attributes}_options", true)
+            dangerous?("#{attributes}_keys", true)
             dangerous?("#{attributes}_texts", true)
+            dangerous?("#{attributes}_options", true)
             dangerous?("#{attribute}_text")
 
-            values_methods.each do |attr, list|
-              list.map(&method(:dangerous?))
+            if set_features?
+              dangerous?("has_#{attributes}", true)
+              dangerous?("has_any_#{attributes}", true)
+            end
+
+            values_methods.each do |attr, (scope, ask, bang, *)|
+              dangerous?(scope, true)
+              dangerous?(bang)
+              dangerous?(ask)
             end
           rescue Interrupt => err
             raise ArgumentError, <<-MSG.squish
@@ -73,14 +87,16 @@ module Torque
 
           # Create all methods needed
           def build
-            @enum_module = Module.new
+            @klass_module = Module.new
+            @instance_module = Module.new
 
             plural
             stringify
             all_values
+            set_scopes if set_features?
 
-            klass.include enum_module
-            klass.extend enum_module::ClassMethods
+            klass.extend klass_module
+            klass.include instance_module
           end
 
           private
@@ -96,78 +112,99 @@ module Torque
                   raise Interrupt, method_name.to_s
                 end
               end
+            rescue Interrupt => e
+              raise e if Torque::PostgreSQL.config.enum.raise_conflicting
+              type = class_method ? 'class method' : 'instance method'
+              indicator = class_method ? '.' : '#'
+
+              Torque::PostgreSQL.logger.info(<<~MSG.squish)
+                Creating #{class_method} :#{method_name} for enum.
+                Overwriting existing method #{klass.name}#{indicator}#{method_name}.
+              MSG
             end
 
             # Create the method that allow access to the list of values
             def plural
-              attr = attribute
-              enum_klass = subtype.klass
-
-              # TODO: Rewrite these as string
-              enum_module.const_set('ClassMethods', Module.new)
-              enum_module::ClassMethods.module_eval do
-                # def self.statuses() statuses end
-                define_method(attr.pluralize) do
-                  enum_klass.values
-                end
-
-                # def self.statuses_texts() members.map(&:text) end
-                define_method(attr.pluralize + '_texts') do
-                  enum_klass.members.map do |member|
-                    member.text(attr, self)
-                  end
-                end
+              enum_klass = subtype.klass.name
+              klass_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def #{attribute.pluralize}                                  # def roles
+                  ::#{enum_klass}.values                                    #   Enum::Roles.values
+                end                                                         # end
+
+                def #{attribute.pluralize}_keys                             # def roles_keys
+                  ::#{enum_klass}.keys                                      #   Enum::Roles.keys
+                end                                                         # end
+
+                def #{attribute.pluralize}_texts                            # def roles_texts
+                  ::#{enum_klass}.members.map do |member|                   #   Enum::Roles.members do |member|
+                    member.text('#{attribute}', self)                       #     member.text('role', self)
+                  end                                                       #   end
+                end                                                         # end
+
+                def #{attribute.pluralize}_options                          # def roles_options
+                  #{attribute.pluralize}_texts.zip(::#{enum_klass}.values)  #   roles_texts.zip(Enum::Roles.values)
+                end                                                         # end
+              RUBY
+            end
 
-                # def self.statuses_options() statuses_texts.zip(statuses) end
-                define_method(attr.pluralize + '_options') do
-                  public_send(attr.pluralize + '_texts').zip(enum_klass.values)
-                end
-              end
+            # Create additional methods when the enum is a set, which needs
+            # better ways to check if values are present or not
+            def set_scopes
+              cast_type = subtype.name.chomp('[]')
+              klass_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def has_#{attribute.pluralize}(*values)                             # def has_roles(*values)
+                  attr = arel_attribute('#{attribute}')                             #   attr = arel_attribute('role')
+                  where(attr.contains(::Arel.array(values, cast: '#{cast_type}')))  #   where(attr.contains(::Arel.array(values, cast: 'roles')))
+                end                                                                 # end
+
+                def has_any_#{attribute.pluralize}(*values)                         # def has_roles(*values)
+                  attr = arel_attribute('#{attribute}')                             #   attr = arel_attribute('role')
+                  where(attr.overlaps(::Arel.array(values, cast: '#{cast_type}')))  #   where(attr.overlaps(::Arel.array(values, cast: 'roles')))
+                end                                                                 # end
+              RUBY
             end
 
             # Create the method that turn the attribute value into text using
             # the model scope
             def stringify
-              attr = attribute
-
-              # TODO: Rewrite these as string
-              enum_module.module_eval do
-                # def status_text() status.text('status', self) end
-                define_method("#{attr}_text") { send(attr)&.text(attr, self) }
-              end
+              instance_module.module_eval <<-RUBY, __FILE__, __LINE__ + 1
+                def #{attribute}_text                      # def role_text
+                  #{attribute}.text('#{attribute}', self)  #   role.text('role', self)
+                end                                        # end
+              RUBY
             end
 
             # Create all the methods that represent actions related to the
             # attribute value
             def all_values
-              attr = attribute
-              vals = values_methods
-
-              enum_klass = subtype.klass
-              model_klass = klass
-
-              # TODO: Rewrite these as string
-              enum_module.module_eval do
-                vals.each do |val, list|
-                  # scope :disabled, -> { where(status: 'disabled') }
-                  model_klass.scope list[0], -> do
-                    where(enum_klass.scope(arel_table[attr], val))
-                  end
-
-                  # def disabled? status.disabled? end
-                  define_method(list[1]) { send(attr).public_send("#{val}?") }
-
-                  # def disabled!
-                  # changed = send(attr).public_send("#{val}!")
-                  # save! if changed && enum_save_on_bang
-                  # true
-                  define_method(list[2]) do
-                    changed = send(attr).public_send("#{val}!")
-                    return save! if changed && enum_save_on_bang
-                    true
-                  end
-                end
+              klass_content = ''
+              instance_content = ''
+              enum_klass = subtype.klass.name
+
+              values_methods.each do |key, (scope, ask, bang, val)|
+                klass_content += <<-RUBY
+                  def #{scope}                                    # def admin
+                    attr = arel_attribute('#{attribute}')         #   attr = arel_attribute('role')
+                    where(::#{enum_klass}.scope(attr, '#{val}'))  #   where(Enum::Roles.scope(attr, 'admin'))
+                  end                                             # end
+                RUBY
+
+                instance_content += <<-RUBY
+                  def #{ask}                                      # def admin?
+                    #{attribute}.#{key}?                          #   role.admin?
+                  end                                             # end
+
+                  def #{bang}                                     # admin!
+                    self.#{attribute} = '#{val}'                  #   self.role = 'admin'
+                    return unless #{attribute}_changed?           #   return unless role_changed?
+                    return save! if Torque::PostgreSQL.config.enum.save_on_bang
+                    true                                          #   true
+                  end                                             # end
+                RUBY
               end
+
+              klass_module.module_eval(klass_content)
+              instance_module.module_eval(instance_content)
             end
         end
       end

data/lib/torque/postgresql/attributes/builder/period.rb

@@ -164,7 +164,7 @@ module Torque
             method_content = define_string_method(method_name, method_content, args)
 
             source_module = send("#{type}_module")
-            source_module.class_eval(method_content)
+            source_module.module_eval(method_content)
           end
 
           private

data/lib/torque/postgresql/attributes/enum.rb

@@ -51,9 +51,14 @@ module Torque
             end
           end
 
+          # List of valus as symbols
+          def keys
+            values.map(&:to_sym)
+          end
+
           # Different from values, it returns the list of items already casted
           def members
-            values.dup.map(&method(:new))
+            values.map(&method(:new))
           end
 
           # Get the list of the values translated by I18n

data/lib/torque/postgresql/attributes/enum_set.rb

@@ -10,7 +10,7 @@ module Torque
           include Enumerable
 
           delegate :each, to: :members
-          delegate :values, :members, :texts, :to_options, :valid?, :size,
+          delegate :values, :keys, :members, :texts, :to_options, :valid?, :size,
             :length, :connection_specification_name, to: :enum_source
 
           # Find or create the class that will handle the value
@@ -28,7 +28,10 @@ module Torque
           # Provide a method on the given class to setup which enum sets will be
           # manually initialized
           def include_on(klass, method_name = nil)
-            Enum.include_on(klass, method_name || Torque::PostgreSQL.config.enum.set_method)
+            method_name ||= Torque::PostgreSQL.config.enum.set_method
+            Builder.include_on(klass, method_name, Builder::Enum, set_features: true) do |builder|
+              defined_enums[builder.attribute.to_sym] = builder.subtype
+            end
           end
 
           # The original Enum implementation, for individual values
@@ -73,7 +76,7 @@ module Torque
 
           # Build an active record scope for a given atribute agains a value
           def scope(attribute, value)
-            attribute.contains(Array.wrap(value))
+            attribute.contains(::Arel.array(value, cast: enum_source.type_name))
           end
 
           private

data/lib/torque/postgresql/auxiliary_statement.rb

@@ -31,11 +31,12 @@ module Torque
         end
 
         # Fast access to statement build
-        def build(statement, base, options = nil, bound_attributes = [])
+        def build(statement, base, options = nil, bound_attributes = [], join_sources = [])
           klass = instantiate(statement, base, options)
           result = klass.build(base)
 
           bound_attributes.concat(klass.bound_attributes)
+          join_sources.concat(klass.join_sources)
           result
         end
 
@@ -105,7 +106,7 @@ module Torque
       delegate :config, :table, :table_name, :relation, :configure, :relation_query?,
         to: :class
 
-      attr_reader :bound_attributes
+      attr_reader :bound_attributes, :join_sources
 
       # Start a new auxiliary statement giving extra options
       def initialize(*args)
@@ -117,15 +118,21 @@ module Torque
         @where = options.fetch(:where, {})
         @select = options.fetch(:select, {})
         @join_type = options.fetch(:join_type, nil)
+
         @bound_attributes = []
+        @join_sources = []
       end
 
       # Build the statement on the given arel and return the WITH statement
       def build(base)
+        @bound_attributes.clear
+        @join_sources.clear
+
+        # Prepare all the data for the statement
         prepare(base)
 
         # Add the join condition to the list
-        base.joins_values += [build_join(base)]
+        @join_sources << build_join(base)
 
         # Return the statement with its dependencies
         [@dependencies, ::Arel::Nodes::As.new(table, build_query(base))]
@@ -205,9 +212,16 @@ module Torque
             end
 
             # Add the scopes defined by the reflection
+            # Possibilities:
+            # table
+            # table, foreign_klass
+            # table, foreign_table, foreign_klass
             if association.respond_to?(:join_scope)
-              args = [@query.arel_table]
-              args << base if association.method(:join_scope).arity.eql?(2)
+              arity = association.method(:join_scope).arity
+              args = [@query.arel_table, foreign_table, base]
+              args.delete_at(1) if arity <= 2 # Delete foreign_table
+              args.delete_at(1) if arity <= 1 # Delete base (foreign_klass)
+
               @query.merge(association.join_scope(*args))
             end
 
@@ -281,7 +295,7 @@ module Torque
               cte.is_a?(dependent_klass)
             end
 
-            AuxiliaryStatement.build(dependent, base, options, bound_attributes)
+            AuxiliaryStatement.build(dependent, base, options, bound_attributes, join_sources)
           end
         end
 

data/lib/torque/postgresql/config.rb

@@ -4,6 +4,12 @@ module Torque
 
     # Stores a version check for compatibility purposes
     AR521 = (ActiveRecord.gem_version >= Gem::Version.new('5.2.1'))
+    AR523 = (ActiveRecord.gem_version >= Gem::Version.new('5.2.3'))
+
+    # Use the same logger as the Active Record one
+    def self.logger
+      ActiveRecord::Base.logger
+    end
 
     # Allow nested configurations
     # :TODO: Rely on +inheritable_copy+ to make nested configurations
@@ -63,6 +69,10 @@ module Torque
       # database or not
       enum.save_on_bang = true
 
+      # Indicates if it should raise errors when a generated method would
+      # conflict with an existing one
+      enum.raise_conflicting = false
+
       # Specify the namespace of each enum type of value
       enum.namespace = ::Object.const_set('Enum', Module.new)
 

data/lib/torque/postgresql/reflection/abstract_reflection.rb

@@ -17,12 +17,28 @@ module Torque
           method(:join_keys).arity.eql?(0) ? join_keys : join_keys(klass)
         end
 
+        # Fix for rails 5.2.3 where the join_scope method is the one now
+        # responsible for building the join condition
+        if Torque::PostgreSQL::AR523
+          def join_scope(table, foreign_table, foreign_klass)
+            return super unless connected_through_array?
+
+            predicate_builder = predicate_builder(table)
+            scope_chain_items = join_scopes(table, predicate_builder)
+            klass_scope       = klass_join_scope(table, predicate_builder)
+
+            klass_scope.where!(build_id_constraint_between(table, foreign_table))
+            klass_scope.where!(type => foreign_klass.polymorphic_name) if type
+            klass_scope.where!(klass.send(:type_condition, table)) \
+              if klass.finder_needs_type_condition?
+
+            scope_chain_items.inject(klass_scope, &:merge!)
+          end
+        end
+
         # Manually build the join constraint
         def build_join_constraint(table, foreign_table)
-          klass_attr = table[torque_join_keys.key.to_s]
-          source_attr = foreign_table[torque_join_keys.foreign_key.to_s]
-
-          result = build_id_constraint(klass_attr, source_attr)
+          result = build_id_constraint_between(table, foreign_table)
           result = table.create_and([result, klass.send(:type_condition, table)]) \
             if klass.finder_needs_type_condition?
 
@@ -61,6 +77,13 @@ module Torque
 
         private
 
+          def build_id_constraint_between(table, foreign_table)
+            klass_attr  = table[torque_join_keys.key.to_s]
+            source_attr = foreign_table[torque_join_keys.foreign_key.to_s]
+
+            build_id_constraint(klass_attr, source_attr)
+          end
+
           # Prepare a value for an array constraint overlap condition
           def cast_constraint_to_array(type, value, should_cast)
             base_ready = type.try(:array) && value.is_a?(AREL_ATTR)

data/lib/torque/postgresql/relation/auxiliary_statement.rb

@@ -47,16 +47,16 @@ module Torque
 
           # Hook arel build to add the distinct on clause
           def build_arel(*)
-            subqueries = build_auxiliary_statements
-            return super if subqueries.nil?
-            super.with(subqueries)
+            arel = super
+            subqueries = build_auxiliary_statements(arel)
+            subqueries.nil? ? arel : arel.with(subqueries)
           end
 
           # Build all necessary data for auxiliary statements
-          def build_auxiliary_statements
-            return unless self.auxiliary_statements_values.present?
-            self.auxiliary_statements_values.map do |klass|
-              klass.build(self)
+          def build_auxiliary_statements(arel)
+            return unless auxiliary_statements_values.present?
+            auxiliary_statements_values.map do |klass|
+              klass.build(self).tap { arel.join_sources.concat(klass.join_sources) }
             end
           end
 

data/lib/torque/postgresql/schema_cache.rb

@@ -11,6 +11,7 @@ module Torque
         @data_sources_model_names = {}
         @inheritance_dependencies = {}
         @inheritance_associations = {}
+        @inheritance_loaded = false
       end
 
       def initialize_dup(*) # :nodoc:
@@ -22,16 +23,16 @@ module Torque
 
       def encode_with(coder) # :nodoc:
         super
-        coder["data_sources_model_names"] = @data_sources_model_names
-        coder["inheritance_dependencies"] = @inheritance_dependencies
-        coder["inheritance_associations"] = @inheritance_associations
+        coder['data_sources_model_names'] = @data_sources_model_names
+        coder['inheritance_dependencies'] = @inheritance_dependencies
+        coder['inheritance_associations'] = @inheritance_associations
       end
 
       def init_with(coder) # :nodoc:
         super
-        @data_sources_model_names = coder["data_sources_model_names"]
-        @inheritance_dependencies = coder["inheritance_dependencies"]
-        @inheritance_associations = coder["inheritance_associations"]
+        @data_sources_model_names = coder['data_sources_model_names']
+        @inheritance_dependencies = coder['inheritance_dependencies']
+        @inheritance_associations = coder['inheritance_associations']
       end
 
       def add(table_name, *) # :nodoc:
@@ -41,6 +42,7 @@ module Torque
         if @data_sources.key?(table_name)
           @inheritance_dependencies.clear
           @inheritance_associations.clear
+          @inheritance_loaded = false
         end
       end
 
@@ -49,6 +51,7 @@ module Torque
         @data_sources_model_names.clear
         @inheritance_dependencies.clear
         @inheritance_associations.clear
+        @inheritance_loaded = false
       end
 
       def size # :nodoc:
@@ -71,10 +74,12 @@ module Torque
           @inheritance_dependencies,
           @inheritance_associations,
           @data_sources_model_names,
+          @inheritance_loaded,
         ]
       end
 
       def marshal_load(array) # :nodoc:
+        @inheritance_loaded = array.pop
         @data_sources_model_names = array.pop
         @inheritance_associations = array.pop
         @inheritance_dependencies = array.pop
@@ -101,13 +106,13 @@ module Torque
       end
 
       # Try to find a model based on a given table
-      def lookup_model(table_name, scopred_class = '')
-        scopred_class = scopred_class.name if scopred_class.is_a?(Class)
+      def lookup_model(table_name, scoped_class = '')
+        scoped_class = scoped_class.name if scoped_class.is_a?(Class)
         return @data_sources_model_names[table_name] \
           if @data_sources_model_names.key?(table_name)
 
         # Get all the possible scopes
-        scopes = scopred_class.scan(/(?:::)?[A-Z][a-z]+/)
+        scopes = scoped_class.scan(/(?:::)?[A-Z][a-z]+/)
         scopes.unshift('Object::')
 
         # Consider the maximum namespaced possible model name
@@ -164,14 +169,17 @@ module Torque
         # Reload information about tables inheritance and dependencies, uses a
         # cache to not perform additional checkes
         def reload_inheritance_data!
-          return if @inheritance_dependencies.present?
+          return if @inheritance_loaded
           @inheritance_dependencies = connection.inherited_tables
           @inheritance_associations = generate_associations
+          @inheritance_loaded = true
         end
 
         # Calculates the inverted dependency (association), where even indirect
         # inheritance comes up in the list
         def generate_associations
+          return {} if @inheritance_dependencies.empty?
+
           result = Hash.new{ |h, k| h[k] = [] }
           masters = @inheritance_dependencies.values.flatten.uniq
 
@@ -200,7 +208,7 @@ module Torque
           super
           @data_sources_model_names = Torque::PostgreSQL.config
             .irregular_models.slice(*@data_sources.keys).map do |table_name, model_name|
-            [table_name, model_name.constantize]
+            [table_name, (model_name.is_a?(Class) ? model_name : model_name.constantize)]
           end.to_h
         end
 

data/lib/torque/postgresql/schema_dumper.rb

@@ -31,21 +31,21 @@ module Torque
           if inherited_tables.present?
             stream.puts "  # These are tables that has inheritance"
             inherited_tables.each do |table_name, inherits|
-              unless ignored?(table_name)
-                sub_stream = StringIO.new
-                table(table_name, sub_stream)
-
-                # Add the inherits setting
-                sub_stream.rewind
-                inherits.map!(&:to_sym)
-                inherits = inherits.first if inherits.size === 1
-                inherits = ", inherits: #{inherits.inspect} do |t|"
-                table_dump = sub_stream.read.gsub(/ do \|t\|$/, inherits)
-
-                # Ensure bodyless definitions
-                table_dump.gsub!(/do \|t\|\n  end/, '')
-                stream.print table_dump
-              end
+              next if ignored?(table_name)
+
+              sub_stream = StringIO.new
+              table(table_name, sub_stream)
+
+              # Add the inherits setting
+              sub_stream.rewind
+              inherits.map!(&:to_sym)
+              inherits = inherits.first if inherits.size === 1
+              inherits = ", inherits: #{inherits.inspect} do |t|"
+              table_dump = sub_stream.read.gsub(/ do \|t\|$/, inherits)
+
+              # Ensure bodyless definitions
+              table_dump.gsub!(/do \|t\|\n  end/, '')
+              stream.print table_dump
             end
           end
 
@@ -63,7 +63,7 @@ module Torque
           return unless types.any?
 
           stream.puts "  # These are user-defined types used on this database"
-          types.each { |name, type| send(type.to_sym, name, stream) }
+          types.sort_by(&:first).each { |name, type| send(type.to_sym, name, stream) }
           stream.puts
         rescue => e
           stream.puts "# Could not dump user-defined types because of following #{e.class}"

data/lib/torque/postgresql/version.rb

@@ -1,5 +1,5 @@
 module Torque
   module PostgreSQL
-    VERSION = '1.1.0'
+    VERSION = '1.1.5'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: torque-postgresql
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.1.5
 platform: ruby
 authors:
 - Carlos Silva
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-03 00:00:00.000000000 Z
+date: 2020-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -260,8 +260,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.8.11
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.14
+rubygems_version: 3.1.4
 signing_key: 
 specification_version: 4
 summary: ActiveRecord extension to access PostgreSQL advanced resources