db_schema 0.2.4 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6a09ea036b2a5cd5dbfe5de0a285d2f88d085cc1
-  data.tar.gz: 3aa56463f84cdeedd5ec878d49fab886d4f12acd
+  metadata.gz: fd3abbf119d7700e83eedf09b10b100cfc744f9e
+  data.tar.gz: d3e8cfd07c1fdcd902e705b337eed52f2bdf8829
 SHA512:
-  metadata.gz: dd2c597cb6e6c768dda725934bad84b70044bb5a44fcb7a4f4c4106d3bb37accc729fabec9683c53830598b17c04051b7e1d0081eadf597346ea19ce295013fb
-  data.tar.gz: 36738c9b037c4526683ee03ca796fe5afb10013a276117308948d30a0c5a485c2da921c33c03b43d0b9638d9b90a8bdfdee392e38e7163fca0c8072c128c8021
+  metadata.gz: 251c126151289b49ea663c2d57c46334d9ba98c9419110121acbb436aee006871eec48aeabbe3ea1a6e6369b1a76fd4ff07e5e9d3cbb0c88e12e13ba609269b2
+  data.tar.gz: a6163f3a147938bad96b7d891f26990fc9c86068f716ec236e4647dda13019c1af9bf1a2ba566fe3c4c8f0b46d5edd6db29ed002eb3212d56590e62fc6baf84f

data/README.md

@@ -1,4 +1,4 @@
-# DbSchema [![Build Status](https://travis-ci.org/7even/db_schema.svg?branch=master)](https://travis-ci.org/7even/db_schema) [![Gem Version](https://badge.fury.io/rb/db_schema.svg)](https://badge.fury.io/rb/db_schema)
+# DbSchema [![Build Status](https://travis-ci.org/7even/db_schema.svg?branch=master)](https://travis-ci.org/7even/db_schema) [![Gem Version](https://badge.fury.io/rb/db_schema.svg)](https://badge.fury.io/rb/db_schema) [![Join the chat at https://gitter.im/7even/db_schema](https://badges.gitter.im/7even/db_schema.svg)](https://gitter.im/7even/db_schema?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
 DbSchema is an opinionated database schema management tool that lets you maintain your DB schema with a single ruby file.
 
@@ -53,7 +53,7 @@ But you would lose it even with manual migrations.
 Add this line to your application's Gemfile:
 
 ``` ruby
-gem 'db_schema', '~> 0.2.4'
+gem 'db_schema', '~> 0.2.5'
 ```
 
 And then execute:
@@ -148,9 +148,9 @@ If your production setup doesn't include multiple workers starting simultaneousl
 ## DSL
 
 Database schema is defined with a block passed to `DbSchema.describe` method.
-This block receives a `db` object on which you can call `#table` to define a table
-and `#enum` to define a custom enum type. Everything that belongs to a specific table
-is described in a block passed to `#table`.
+This block receives a `db` object on which you can call `#table` to define a table,
+`#enum` to define a custom enum type and `#extension` to plug a Postgres extension into your database.
+Everything that belongs to a specific table is described in a block passed to `#table`.
 
 ``` ruby
 DbSchema.describe do |db|
@@ -500,13 +500,15 @@ db.table :users do |t|
 end
 ```
 
-After the enum type is created, you can add more values to it. They don't have to appear in the end of the values list - you can add new values to the middle or even to the beginning of the list:
+Arrays of enums are also supported - they are described just like arrays of any other element type:
 
 ``` ruby
-db.enum :user_status, [:guest, :registered, :sent_confirmation_email, :confirmed_email, :subscriber]
-```
+db.enum :user_role, [:user, :manager, :admin]
 
-Reordering and deleting values from enum types is not supported.
+db.table :users do |t|
+  t.array :roles, of: :user_role, default: '{user}'
+end
+```
 
 ### Extensions
 

data/lib/db_schema.rb

@@ -18,7 +18,7 @@ module DbSchema
     def describe(&block)
       desired_schema = DSL.new(block).schema
       validate(desired_schema)
-      Normalizer.normalize_tables(desired_schema)
+      Normalizer.new(desired_schema).normalize_tables
 
       actual_schema = Reader.read_schema
       changes = Changes.between(desired_schema, actual_schema)

data/lib/db_schema/awesome_print.rb

@@ -15,6 +15,8 @@ if defined?(AwesomePrint)
         case object
         when ::DbSchema::Definitions::Schema
           :dbschema_schema
+        when ::DbSchema::Definitions::NullTable
+          :dbschema_null_table
         when ::DbSchema::Definitions::Table
           :dbschema_table
         when ::DbSchema::Definitions::Field::Custom
@@ -55,11 +57,11 @@ if defined?(AwesomePrint)
         when ::DbSchema::Changes::AlterColumnDefault
           :dbschema_alter_column_default
         when ::DbSchema::Changes::CreateIndex
-          :dbschema_index
+          :dbschema_create_index
         when ::DbSchema::Changes::DropIndex
           :dbschema_column_operation
         when ::DbSchema::Changes::CreateCheckConstraint
-          :dbschema_check_constraint
+          :dbschema_create_check_constraint
         when ::DbSchema::Changes::DropCheckConstraint
           :dbschema_column_operation
         when ::DbSchema::Changes::CreateForeignKey
@@ -67,13 +69,14 @@ if defined?(AwesomePrint)
         when ::DbSchema::Changes::DropForeignKey
           :dbschema_drop_foreign_key
         when ::DbSchema::Changes::CreateEnum
-          :dbschema_enum
+          :dbschema_create_enum
         when ::DbSchema::Changes::DropEnum
           :dbschema_column_operation
-        when ::DbSchema::Changes::AddValueToEnum
-          :dbschema_add_value_to_enum
-        when ::DbSchema::Changes::CreateExtension,
-             ::DbSchema::Changes::DropExtension
+        when ::DbSchema::Changes::AlterEnumValues
+          :dbschema_alter_enum_values
+        when ::DbSchema::Changes::CreateExtension
+          :dbschema_create_extension
+        when ::DbSchema::Changes::DropExtension
           :dbschema_column_operation
         else
           cast_without_dbschema(object, type)
@@ -100,6 +103,10 @@ if defined?(AwesomePrint)
         "#<DbSchema::Definitions::Table #{object.name.ai} #{data_string}>"
       end
 
+      def awesome_dbschema_null_table(object)
+        '#<DbSchema::Definitions::NullTable>'
+      end
+
       def awesome_dbschema_field(object)
         options = object.options.map do |k, v|
           key = colorize("#{k}:", :symbol)
@@ -190,12 +197,12 @@ if defined?(AwesomePrint)
       end
 
       def awesome_dbschema_create_table(object)
-        data = ["fields: #{object.fields.ai}"]
-        data << "indices: #{object.indices.ai}" if object.indices.any?
-        data << "checks: #{object.checks.ai}" if object.checks.any?
+        data = ["fields: #{object.table.fields.ai}"]
+        data << "indices: #{object.table.indices.ai}" if object.table.indices.any?
+        data << "checks: #{object.table.checks.ai}" if object.table.checks.any?
 
         data_string = indent_lines(data.join(', '))
-        "#<DbSchema::Changes::CreateTable #{object.name.ai} #{data_string}>"
+        "#<DbSchema::Changes::CreateTable #{object.table.name.ai} #{data_string}>"
       end
 
       def awesome_dbschema_drop_table(object)
@@ -203,12 +210,7 @@ if defined?(AwesomePrint)
       end
 
       def awesome_dbschema_alter_table(object)
-        data = ["fields: #{object.fields.ai}"]
-        data << "indices: #{object.indices.ai}" if object.indices.any?
-        data << "checks: #{object.checks.ai}" if object.checks.any?
-
-        data_string = indent_lines(data.join(', '))
-        "#<DbSchema::Changes::AlterTable #{object.name.ai} #{data_string}>"
+        "#<DbSchema::Changes::AlterTable #{object.table_name.ai} #{indent_lines(object.changes.ai)}>"
       end
 
       def awesome_dbschema_create_column(object)
@@ -242,6 +244,21 @@ if defined?(AwesomePrint)
         "#<DbSchema::Changes::AlterColumnDefault #{object.name.ai}, #{new_default}>"
       end
 
+      def awesome_dbschema_create_index(object)
+        columns = format_dbschema_fields(object.index.columns)
+        using = ' using ' + colorize(object.index.type.to_s, :symbol) unless object.index.btree?
+
+        data = [nil]
+        data << colorize('unique', :nilclass) if object.index.unique?
+        data << colorize('condition: ', :symbol) + object.index.condition.ai unless object.index.condition.nil?
+
+        "#<#{object.class} #{object.index.name.ai} on #{columns}#{using}#{data.join(', ')}>"
+      end
+
+      def awesome_dbschema_create_check_constraint(object)
+        "#<#{object.class} #{object.check.name.ai} #{object.check.condition.ai}>"
+      end
+
       def awesome_dbschema_create_foreign_key(object)
         "#<DbSchema::Changes::CreateForeignKey #{object.foreign_key.ai} on #{object.table_name.ai}>"
       end
@@ -250,14 +267,28 @@ if defined?(AwesomePrint)
         "#<DbSchema::Changes::DropForeignKey #{object.fkey_name.ai} on #{object.table_name.ai}>"
       end
 
+      def awesome_dbschema_create_enum(object)
+        values = object.enum.values.map do |value|
+          colorize(value.to_s, :string)
+        end.join(', ')
+
+        "#<#{object.class} #{object.enum.name.ai} (#{values})>"
+      end
+
       def awesome_dbschema_column_operation(object)
         "#<#{object.class} #{object.name.ai}>"
       end
 
-      def awesome_dbschema_add_value_to_enum(object)
-        before = " before #{object.before.ai}" unless object.add_to_the_end?
+      def awesome_dbschema_alter_enum_values(object)
+        values = object.new_values.map do |value|
+          colorize(value.to_s, :string)
+        end.join(', ')
+
+        "#<DbSchema::Changes::AlterEnumValues #{object.enum_name.ai} to (#{values})>"
+      end
 
-        "#<DbSchema::Changes::AddValueToEnum #{object.new_value.ai} to #{object.enum_name.ai}#{before}>"
+      def awesome_dbschema_create_extension(object)
+        "#<#{object.class} #{object.extension.name.ai}>"
       end
 
       def format_dbschema_fields(fields)

data/lib/db_schema/changes.rb

@@ -12,12 +12,7 @@ module DbSchema
           actual  = actual_schema.tables.find  { |table| table.name == table_name }
 
           if desired && !actual
-            changes << CreateTable.new(
-              table_name,
-              fields:  desired.fields,
-              indices: desired.indices,
-              checks:  desired.checks
-            )
+            changes << CreateTable.new(desired)
 
             fkey_operations = desired.foreign_keys.map do |fkey|
               CreateForeignKey.new(table_name, fkey)
@@ -38,9 +33,7 @@ module DbSchema
             if field_operations.any? || index_operations.any? || check_operations.any?
               changes << AlterTable.new(
                 table_name,
-                fields:  field_operations,
-                indices: index_operations,
-                checks:  check_operations
+                field_operations + index_operations + check_operations
               )
             end
 
@@ -55,36 +48,37 @@ module DbSchema
           actual  = actual_schema.enums.find  { |enum| enum.name == enum_name }
 
           if desired && !actual
-            changes << CreateEnum.new(enum_name, desired.values)
+            changes << CreateEnum.new(desired)
           elsif actual && !desired
             changes << DropEnum.new(enum_name)
           elsif actual != desired
-            new_values     = desired.values - actual.values
-            dropped_values = actual.values - desired.values
-
-            if dropped_values.any?
-              raise UnsupportedOperation, "Enum #{enum_name.inspect} doesn't describe values #{dropped_values.inspect} that are present in the database; dropping values from enums is not supported."
-            end
-
-            if desired.values - new_values != actual.values
-              raise UnsupportedOperation, "Enum #{enum_name.inspect} describes values #{(desired.values - new_values).inspect} that are present in the database in a different order (#{actual.values.inspect}); reordering values in enums is not supported."
-            end
-
-            new_values.reverse.each do |value|
-              value_index = desired.values.index(value)
-
-              if value_index == desired.values.count - 1
-                changes << AddValueToEnum.new(enum_name, value)
-              else
-                next_value = desired.values[value_index + 1]
-                changes << AddValueToEnum.new(enum_name, value, before: next_value)
+            fields = actual_schema.tables.flat_map do |table|
+              table.fields.select do |field|
+                if field.array?
+                  field.attributes[:element_type] == enum_name
+                else
+                  field.type == enum_name
+                end
+              end.map do |field|
+                if desired_field = desired_schema[table.name][field.name]
+                  new_default = desired_field.default
+                end
+
+                {
+                  table_name:  table.name,
+                  field_name:  field.name,
+                  new_default: new_default,
+                  array:       field.array?
+                }
               end
             end
+
+            changes << AlterEnumValues.new(enum_name, desired.values, fields)
           end
         end
 
         extension_changes = (desired_schema.extensions - actual_schema.extensions).map do |extension|
-          CreateExtension.new(extension.name)
+          CreateExtension.new(extension)
         end + (actual_schema.extensions - desired_schema.extensions).map do |extension|
           DropExtension.new(extension.name)
         end
@@ -144,24 +138,12 @@ module DbSchema
           actual  = actual_indices.find  { |index| index.name == index_name }
 
           if desired && !actual
-            table_changes << CreateIndex.new(
-              name:      index_name,
-              columns:   desired.columns,
-              unique:    desired.unique?,
-              type:      desired.type,
-              condition: desired.condition
-            )
+            table_changes << CreateIndex.new(desired)
           elsif actual && !desired
             table_changes << DropIndex.new(index_name)
           elsif actual != desired
             table_changes << DropIndex.new(index_name)
-            table_changes << CreateIndex.new(
-              name:      index_name,
-              columns:   desired.columns,
-              unique:    desired.unique?,
-              type:      desired.type,
-              condition: desired.condition
-            )
+            table_changes << CreateIndex.new(desired)
           end
         end
       end
@@ -174,18 +156,12 @@ module DbSchema
           actual  = actual_checks.find  { |check| check.name == check_name }
 
           if desired && !actual
-            table_changes << CreateCheckConstraint.new(
-              name:      check_name,
-              condition: desired.condition
-            )
+            table_changes << CreateCheckConstraint.new(desired)
           elsif actual && !desired
             table_changes << DropCheckConstraint.new(check_name)
           elsif actual != desired
             table_changes << DropCheckConstraint.new(check_name)
-            table_changes << CreateCheckConstraint.new(
-              name:      check_name,
-              condition: desired.condition
-            )
+            table_changes << CreateCheckConstraint.new(desired)
           end
         end
       end
@@ -197,37 +173,24 @@ module DbSchema
           desired = desired_foreign_keys.find { |key| key.name == key_name }
           actual  = actual_foreign_keys.find  { |key| key.name == key_name }
 
-          foreign_key = Definitions::ForeignKey.new(
-            name:       key_name,
-            fields:     desired.fields,
-            table:      desired.table,
-            keys:       desired.keys,
-            on_delete:  desired.on_delete,
-            on_update:  desired.on_update,
-            deferrable: desired.deferrable?
-          ) if desired
-
           if desired && !actual
-            table_changes << CreateForeignKey.new(table_name, foreign_key)
+            table_changes << CreateForeignKey.new(table_name, desired)
           elsif actual && !desired
             table_changes << DropForeignKey.new(table_name, key_name)
           elsif actual != desired
             table_changes << DropForeignKey.new(table_name, key_name)
-            table_changes << CreateForeignKey.new(table_name, foreign_key)
+            table_changes << CreateForeignKey.new(table_name, desired)
           end
         end
       end
     end
 
     class CreateTable
-      include Dry::Equalizer(:name, :fields, :indices, :checks)
-      attr_reader :name, :fields, :indices, :checks
-
-      def initialize(name, fields: [], indices: [], checks: [])
-        @name    = name
-        @fields  = fields
-        @indices = indices
-        @checks  = checks
+      include Dry::Equalizer(:table)
+      attr_reader :table
+
+      def initialize(table)
+        @table = table
       end
     end
 
@@ -241,14 +204,12 @@ module DbSchema
     end
 
     class AlterTable
-      include Dry::Equalizer(:name, :fields, :indices, :checks)
-      attr_reader :name, :fields, :indices, :checks
-
-      def initialize(name, fields: [], indices: [], checks: [])
-        @name    = name
-        @fields  = fields
-        @indices = indices
-        @checks  = checks
+      include Dry::Equalizer(:table_name, :changes)
+      attr_reader :table_name, :changes
+
+      def initialize(table_name, changes)
+        @table_name = table_name
+        @changes    = changes
       end
     end
 
@@ -332,13 +293,25 @@ module DbSchema
       end
     end
 
-    class CreateIndex < Definitions::Index
+    class CreateIndex
+      include Dry::Equalizer(:index)
+      attr_reader :index
+
+      def initialize(index)
+        @index = index
+      end
     end
 
     class DropIndex < ColumnOperation
     end
 
-    class CreateCheckConstraint < Definitions::CheckConstraint
+    class CreateCheckConstraint
+      include Dry::Equalizer(:check)
+      attr_reader :check
+
+      def initialize(check)
+        @check = check
+      end
     end
 
     class DropCheckConstraint < ColumnOperation
@@ -364,28 +337,36 @@ module DbSchema
       end
     end
 
-    class CreateEnum < Definitions::Enum
+    class CreateEnum
+      include Dry::Equalizer(:enum)
+      attr_reader :enum
+
+      def initialize(enum)
+        @enum = enum
+      end
     end
 
     class DropEnum < ColumnOperation
     end
 
-    class AddValueToEnum
-      include Dry::Equalizer(:enum_name, :new_value, :before)
-      attr_reader :enum_name, :new_value, :before
-
-      def initialize(enum_name, new_value, before: nil)
-        @enum_name = enum_name
-        @new_value = new_value
-        @before    = before
-      end
+    class AlterEnumValues
+      include Dry::Equalizer(:enum_name, :new_values, :enum_fields)
+      attr_reader :enum_name, :new_values, :enum_fields
 
-      def add_to_the_end?
-        before.nil?
+      def initialize(enum_name, new_values, enum_fields)
+        @enum_name   = enum_name
+        @new_values  = new_values
+        @enum_fields = enum_fields
       end
     end
 
-    class CreateExtension < Definitions::Extension
+    class CreateExtension
+      include Dry::Equalizer(:extension)
+      attr_reader :extension
+
+      def initialize(extension)
+        @extension = extension
+      end
     end
 
     class DropExtension < ColumnOperation

data/lib/db_schema/definitions.rb

@@ -12,6 +12,10 @@ module DbSchema
         @enums      = enums
         @extensions = extensions
       end
+
+      def [](table_name)
+        tables.find { |table| table.name == table_name } || NullTable.new
+      end
     end
 
     class Table
@@ -31,6 +35,54 @@ module DbSchema
           indices.any?(&:has_expressions?) ||
           checks.any?
       end
+
+      def [](field_name)
+        fields.find { |field| field.name == field_name }
+      end
+
+      def with_name(new_name)
+        Table.new(
+          new_name,
+          fields:       fields,
+          indices:      indices,
+          checks:       checks,
+          foreign_keys: foreign_keys
+        )
+      end
+
+      def with_fields(new_fields)
+        Table.new(
+          name,
+          fields:       new_fields,
+          indices:      indices,
+          checks:       checks,
+          foreign_keys: foreign_keys
+        )
+      end
+
+      def with_indices(new_indices)
+        Table.new(
+          name,
+          fields:       fields,
+          indices:      new_indices,
+          checks:       checks,
+          foreign_keys: foreign_keys
+        )
+      end
+
+      def with_foreign_keys(new_foreign_keys)
+        Table.new(
+          name,
+          fields:       fields,
+          indices:      indices,
+          checks:       checks,
+          foreign_keys: new_foreign_keys
+        )
+      end
+    end
+
+    class NullTable < Table
+      def initialize; end
     end
 
     class Index
@@ -65,6 +117,16 @@ module DbSchema
         !condition.nil? || columns.any?(&:expression?)
       end
 
+      def with_name(new_name)
+        Index.new(
+          name:      new_name,
+          columns:   columns,
+          unique:    unique?,
+          type:      type,
+          condition: condition
+        )
+      end
+
       class Column
         include Dry::Equalizer(:name, :order, :nulls)
         attr_reader :name, :order, :nulls
@@ -173,6 +235,10 @@ module DbSchema
         @name   = name
         @values = values
       end
+
+      def with_name(new_name)
+        Enum.new(new_name, values)
+      end
     end
 
     class Extension

data/lib/db_schema/definitions/field/array.rb

@@ -3,16 +3,27 @@ module DbSchema
     module Field
       class Array < Base
         register :array
-        attr_reader :element_type
 
-        def initialize(name, of:, **options)
-          super(name, **options)
-          @element_type = Field.type_class_for(of)
+        def initialize(name, **options)
+          type_class = Field.type_class_for(options[:element_type])
+          super(name, **options.merge(element_type: type_class))
         end
 
         def attributes
           super.merge(element_type: element_type.type)
         end
+
+        def array?
+          true
+        end
+
+        def element_type
+          @attributes[:element_type]
+        end
+
+        def custom_element_type?
+          element_type.superclass == Custom
+        end
       end
     end
   end

data/lib/db_schema/definitions/field/base.rb

@@ -25,6 +25,14 @@ module DbSchema
           default.is_a?(Symbol)
         end
 
+        def array?
+          false
+        end
+
+        def custom?
+          false
+        end
+
         def options
           attributes.tap do |options|
             options[:null] = false unless null?
@@ -48,6 +56,14 @@ module DbSchema
           self.class.type
         end
 
+        def with_type(new_type)
+          Field.build(name, new_type, **options, primary_key: primary_key?)
+        end
+
+        def with_attribute(attr_name, attr_value)
+          Field.build(name, type, **options, primary_key: primary_key?, attr_name => attr_value)
+        end
+
         class << self
           def register(*types)
             types.each do |type|

data/lib/db_schema/definitions/field/custom.rb

@@ -6,7 +6,7 @@ module DbSchema
           def class_for(type_name)
             raise ArgumentError if type_name.nil?
 
-            Class.new(self) do
+            custom_types[type_name] ||= Class.new(self) do
               define_method :type do
                 type_name
               end
@@ -14,8 +14,17 @@ module DbSchema
               define_singleton_method :type do
                 type_name
               end
+
+              define_method :custom? do
+                true
+              end
             end
           end
+
+        private
+          def custom_types
+            @custom_types ||= {}
+          end
         end
       end
     end

data/lib/db_schema/dsl.rb

@@ -42,11 +42,17 @@ module DbSchema
       end
 
       DbSchema::Definitions::Field.registry.keys.each do |type|
+        next if type == :array
+
         define_method(type) do |name, **options|
           field(name, type, options)
         end
       end
 
+      def array(name, of:, **options)
+        field(name, :array, element_type: of, **options)
+      end
+
       def method_missing(method_name, name, *args, &block)
         field(name, method_name, args.first || {})
       end

data/lib/db_schema/normalizer.rb

@@ -2,118 +2,139 @@ require 'digest/md5'
 
 module DbSchema
   class Normalizer
-    attr_reader :table
-
-    class << self
-      def normalize_tables(schema)
-        DbSchema.connection.transaction do
-          create_extensions!(schema.extensions)
-          create_enums!(schema.enums)
-
-          schema.tables = schema.tables.map do |table|
-            if table.has_expressions?
-              new(table).normalized_table
-            else
-              table
-            end
-          end
+    attr_reader :schema
+
+    def initialize(schema)
+      @schema = schema
+    end
+
+    def normalize_tables
+      DbSchema.connection.transaction do
+        create_extensions!
+        create_enums!
 
-          raise Sequel::Rollback
+        schema.tables = schema.tables.map do |table|
+          if table.has_expressions?
+            Table.new(table, hash).normalized_table
+          else
+            table
+          end
         end
+
+        raise Sequel::Rollback
       end
+    end
 
-    private
-      def create_extensions!(extensions)
-        (extensions - DbSchema::Reader.read_extensions).each do |extension|
-          operation = DbSchema::Changes::CreateExtension.new(extension.name)
-          DbSchema::Runner.new([operation]).run!
-        end
+  private
+    def create_extensions!
+      operations = (schema.extensions - Reader.read_extensions).map do |extension|
+        Changes::CreateExtension.new(extension)
       end
 
-      def create_enums!(enums)
-        existing_enums_names = DbSchema::Reader.read_enums.map(&:name)
-        enums.each do |enum|
-          next if existing_enums_names.include?(enum.name)
+      Runner.new(operations).run!
+    end
 
-          operation = DbSchema::Changes::CreateEnum.new(enum.name, enum.values)
-          DbSchema::Runner.new([operation]).run!
-        end
+    def create_enums!
+      operations = schema.enums.map do |enum|
+        Changes::CreateEnum.new(enum.with_name(append_hash(enum.name)))
       end
-    end
 
-    def initialize(table)
-      @table = table
+      Runner.new(operations).run!
     end
 
-    def normalized_table
-      create_temporary_table!
-      read_temporary_table
+    def append_hash(name)
+      "#{name}_#{hash}"
     end
 
-  private
-    def create_temporary_table!
-      operation = Changes::CreateTable.new(
-        temporary_table_name,
-        fields:  table.fields,
-        indices: rename_indices(table.indices),
-        checks:  table.checks
-      )
-
-      Runner.new([operation]).run!
+    def hash
+      @hash ||= begin
+        names = schema.tables.flat_map do |table|
+          [table.name] + table.fields.map(&:name) + table.indices.map(&:name) + table.checks.map(&:name)
+        end
+
+        Digest::MD5.hexdigest(names.join(','))[0..9]
+      end
     end
 
-    def read_temporary_table
-      temporary_table = Reader.read_table(temporary_table_name)
+    class Table
+      attr_reader :table, :hash
 
-      Definitions::Table.new(
-        remove_hash(temporary_table.name),
-        fields:       temporary_table.fields,
-        indices:      rename_indices_back(temporary_table.indices),
-        checks:       temporary_table.checks,
-        foreign_keys: table.foreign_keys
-      )
-    end
+      def initialize(table, hash)
+        @table = table
+        @hash  = hash
+      end
 
-    def rename_indices(indices)
-      indices.map do |index|
-        Definitions::Index.new(
-          name:      append_hash(index.name),
-          columns:   index.columns,
-          unique:    index.unique?,
-          type:      index.type,
-          condition: index.condition
-        )
+      def normalized_table
+        create_temporary_table!
+        read_temporary_table
       end
-    end
 
-    def rename_indices_back(indices)
-      indices.map do |index|
-        Definitions::Index.new(
-          name:      remove_hash(index.name),
-          columns:   index.columns,
-          unique:    index.unique?,
-          type:      index.type,
-          condition: index.condition
+    private
+      def create_temporary_table!
+        operation = Changes::CreateTable.new(
+          table.with_name(temporary_table_name)
+            .with_fields(rename_types(table.fields))
+            .with_indices(rename_indices(table.indices))
         )
+
+        Runner.new([operation]).run!
       end
-    end
 
-    def temporary_table_name
-      append_hash(table.name)
-    end
+      def read_temporary_table
+        temporary_table = Reader.read_table(temporary_table_name)
 
-    def append_hash(name)
-      "#{name}_#{hash}"
-    end
+        temporary_table.with_name(table.name)
+          .with_fields(rename_types_back(temporary_table.fields))
+          .with_indices(rename_indices_back(temporary_table.indices))
+          .with_foreign_keys(table.foreign_keys)
+      end
 
-    def remove_hash(name)
-      name.to_s.sub(/_#{Regexp.escape(hash)}$/, '').to_sym
-    end
+      def rename_types(fields)
+        fields.map do |field|
+          if field.custom?
+            field.with_type(append_hash(field.type))
+          elsif field.array? && field.custom_element_type?
+            field.with_attribute(:element_type, append_hash(field.element_type.type).to_sym)
+          else
+            field
+          end
+        end
+      end
 
-    def hash
-      @hash ||= begin
-        names = [table.name] + table.fields.map(&:name) + table.indices.map(&:name) + table.checks.map(&:name)
-        Digest::MD5.hexdigest(names.join(','))[0..9]
+      def rename_types_back(fields)
+        fields.map do |field|
+          if field.custom?
+            field.with_type(remove_hash(field.type))
+          elsif field.array? && field.custom_element_type?
+            field.with_attribute(:element_type, remove_hash(field.element_type.type).to_sym)
+          else
+            field
+          end
+        end
+      end
+
+      def rename_indices(indices)
+        indices.map do |index|
+          index.with_name(append_hash(index.name))
+        end
+      end
+
+      def rename_indices_back(indices)
+        indices.map do |index|
+          index.with_name(remove_hash(index.name))
+        end
+      end
+
+      def temporary_table_name
+        append_hash(table.name)
+      end
+
+      def append_hash(name)
+        "#{name}_#{hash}"
+      end
+
+      def remove_hash(name)
+        name.to_s.sub(/_#{Regexp.escape(hash)}$/, '').to_sym
       end
     end
   end

data/lib/db_schema/reader.rb

@@ -298,7 +298,7 @@ SELECT extname
             Utils.rename_keys(
               Utils.filter_by_keys(data, :element_type, :element_custom_type_name)
             ) do |attributes|
-              attributes[:of] = if attributes[:element_type] == 'USER-DEFINED'
+              attributes[:element_type] = if attributes[:element_type] == 'USER-DEFINED'
                 attributes[:element_custom_type_name]
               else
                 attributes[:element_type]

data/lib/db_schema/runner.rb

@@ -24,6 +24,8 @@ module DbSchema
             self.class.create_enum(change)
           when Changes::DropEnum
             self.class.drop_enum(change)
+          when Changes::AlterEnumValues
+            self.class.alter_enum_values(change)
           when Changes::CreateExtension
             self.class.create_extension(change)
           when Changes::DropExtension
@@ -31,11 +33,6 @@ module DbSchema
           end
         end
       end
-
-      # Postgres doesn't allow modifying enums inside a transaction
-      Utils.filter_by_class(changes, Changes::AddValueToEnum).each do |change|
-        self.class.add_value_to_enum(change)
-      end
     end
 
   private
@@ -44,8 +41,8 @@ module DbSchema
         changes,
         [
           Changes::CreateExtension,
-          Changes::AddValueToEnum,
           Changes::DropForeignKey,
+          Changes::AlterEnumValues,
           Changes::CreateEnum,
           Changes::CreateTable,
           Changes::AlterTable,
@@ -59,8 +56,8 @@ module DbSchema
 
     class << self
       def create_table(change)
-        DbSchema.connection.create_table(change.name) do
-          change.fields.each do |field|
+        DbSchema.connection.create_table(change.table.name) do
+          change.table.fields.each do |field|
             if field.primary_key?
               primary_key(field.name)
             else
@@ -69,7 +66,7 @@ module DbSchema
             end
           end
 
-          change.indices.each do |index|
+          change.table.indices.each do |index|
             index(
               index.columns_to_sequel,
               name:   index.name,
@@ -79,7 +76,7 @@ module DbSchema
             )
           end
 
-          change.checks.each do |check|
+          change.table.checks.each do |check|
             constraint(check.name, check.condition)
           end
         end
@@ -90,9 +87,9 @@ module DbSchema
       end
 
       def alter_table(change)
-        DbSchema.connection.alter_table(change.name) do
+        DbSchema.connection.alter_table(change.table_name) do
           Utils.sort_by_class(
-            change.fields + change.indices + change.checks,
+            change.changes,
             [
               DbSchema::Changes::DropPrimaryKey,
               DbSchema::Changes::DropCheckConstraint,
@@ -136,16 +133,16 @@ module DbSchema
               set_column_default(element.name, Runner.default_to_sequel(element.new_default))
             when Changes::CreateIndex
               add_index(
-                element.columns_to_sequel,
-                name:   element.name,
-                unique: element.unique?,
-                type:   element.type,
-                where:  element.condition
+                element.index.columns_to_sequel,
+                name:   element.index.name,
+                unique: element.index.unique?,
+                type:   element.index.type,
+                where:  element.index.condition
               )
             when Changes::DropIndex
               drop_index([], name: element.name)
             when Changes::CreateCheckConstraint
-              add_constraint(element.name, element.condition)
+              add_constraint(element.check.name, element.check.condition)
             when Changes::DropCheckConstraint
               drop_constraint(element.name)
             end
@@ -166,23 +163,45 @@ module DbSchema
       end
 
       def create_enum(change)
-        DbSchema.connection.create_enum(change.name, change.values)
+        DbSchema.connection.create_enum(change.enum.name, change.enum.values)
       end
 
       def drop_enum(change)
         DbSchema.connection.drop_enum(change.name)
       end
 
-      def add_value_to_enum(change)
-        if change.add_to_the_end?
-          DbSchema.connection.add_enum_value(change.enum_name, change.new_value)
-        else
-          DbSchema.connection.add_enum_value(change.enum_name, change.new_value, before: change.before)
+      def alter_enum_values(change)
+        change.enum_fields.each do |field_data|
+          DbSchema.connection.alter_table(field_data[:table_name]) do
+            set_column_type(field_data[:field_name], :VARCHAR)
+            set_column_default(field_data[:field_name], nil)
+          end
+        end
+
+        DbSchema.connection.drop_enum(change.enum_name)
+        DbSchema.connection.create_enum(change.enum_name, change.new_values)
+
+        change.enum_fields.each do |field_data|
+          DbSchema.connection.alter_table(field_data[:table_name]) do
+            field_type = if field_data[:array]
+              "#{change.enum_name}[]"
+            else
+              change.enum_name
+            end
+
+            set_column_type(
+              field_data[:field_name],
+              field_type,
+              using: "#{field_data[:field_name]}::#{field_type}"
+            )
+
+            set_column_default(field_data[:field_name], field_data[:new_default]) unless field_data[:new_default].nil?
+          end
         end
       end
 
       def create_extension(change)
-        DbSchema.connection.run(%Q(CREATE EXTENSION "#{change.name}"))
+        DbSchema.connection.run(%Q(CREATE EXTENSION "#{change.extension.name}"))
       end
 
       def drop_extension(change)

data/lib/db_schema/validator.rb

@@ -1,3 +1,5 @@
+require 'sequel/extensions/pg_array'
+
 module DbSchema
   module Validator
     class << self
@@ -10,10 +12,29 @@ module DbSchema
           end
 
           table.fields.each do |field|
-            if field.is_a?(Definitions::Field::Custom)
-              unless schema.enums.map(&:name).include?(field.type)
+            if field.custom?
+              type = schema.enums.find { |enum| enum.name == field.type }
+
+              if type.nil?
                 error_message = %(Field "#{table.name}.#{field.name}" has unknown type "#{field.type}")
                 errors << error_message
+              elsif !field.default.nil? && !type.values.include?(field.default.to_sym)
+                errors << %(Field "#{table.name}.#{field.name}" has invalid default value "#{field.default}" (valid values are #{type.values.map(&:to_s)}))
+              end
+            elsif field.array? && field.custom_element_type?
+              type = schema.enums.find { |enum| enum.name == field.element_type.type }
+
+              if type.nil?
+                error_message = %(Array field "#{table.name}.#{field.name}" has unknown element type "#{field.element_type.type}")
+                errors << error_message
+              elsif !field.default.nil?
+                default_array  = Sequel::Postgres::PGArray::Parser.new(field.default).parse.map(&:to_sym)
+                invalid_values = default_array - type.values
+
+                if invalid_values.any?
+                  error_message = %(Array field "#{table.name}.#{field.name}" has invalid default value #{default_array.map(&:to_s)} (valid values are #{type.values.map(&:to_s)}))
+                  errors << error_message
+                end
               end
             end
           end

data/lib/db_schema/version.rb

@@ -1,3 +1,3 @@
 module DbSchema
-  VERSION = '0.2.4'
+  VERSION = '0.2.5'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: db_schema
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors:
 - Vsevolod Romashov
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-12-11 00:00:00.000000000 Z
+date: 2017-04-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sequel
@@ -240,7 +240,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.5.2
 signing_key: 
 specification_version: 4
 summary: Declarative database schema definition.