db_schema 0.2.5 → 0.3.rc1

data/lib/db_schema/definitions/index/column.rb

@@ -0,0 +1,32 @@
+module DbSchema
+  module Definitions
+    class Index
+      class Column
+        include Dry::Equalizer(:name, :order, :nulls)
+        attr_reader :name, :order, :nulls
+
+        def initialize(name, order: :asc, nulls: order == :asc ? :last : :first)
+          @name  = name
+          @order = order
+          @nulls = nulls
+        end
+
+        def asc?
+          @order == :asc
+        end
+
+        def desc?
+          @order == :desc
+        end
+
+        def ordered_expression
+          if asc?
+            Sequel.asc(to_sequel, nulls: nulls)
+          else
+            Sequel.desc(to_sequel, nulls: nulls)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/db_schema/definitions/index/expression.rb

@@ -0,0 +1,19 @@
+module DbSchema
+  module Definitions
+    class Index
+      class Expression < Column
+        def expression?
+          true
+        end
+
+        def index_name_segment
+          name.scan(/\b[A-Za-z0-9_]+\b/).join('_')
+        end
+
+        def to_sequel
+          Sequel.lit("(#{name})")
+        end
+      end
+    end
+  end
+end

data/lib/db_schema/definitions/index/table_field.rb

@@ -0,0 +1,19 @@
+module DbSchema
+  module Definitions
+    class Index
+      class TableField < Column
+        def expression?
+          false
+        end
+
+        def index_name_segment
+          name
+        end
+
+        def to_sequel
+          name
+        end
+      end
+    end
+  end
+end

data/lib/db_schema/definitions/schema.rb

@@ -0,0 +1,36 @@
+module DbSchema
+  module Definitions
+    class Schema
+      include Dry::Equalizer(:tables, :enums, :extensions)
+      attr_reader :tables, :enums, :extensions
+      attr_writer :tables
+
+      def initialize(tables: [], enums: [], extensions: [])
+        @tables     = tables
+        @enums      = enums
+        @extensions = extensions
+      end
+
+      def table(table_name)
+        tables.find { |table| table.name == table_name } || NullTable.new
+      end
+      alias_method :[], :table
+
+      def has_table?(table_name)
+        !table(table_name).is_a?(NullTable)
+      end
+
+      def enum(enum_name)
+        enums.find { |enum| enum.name == enum_name } || NullEnum.new
+      end
+
+      def has_enum?(enum_name)
+        !enum(enum_name).is_a?(NullEnum)
+      end
+
+      def has_extension?(extension_name)
+        extensions.any? { |extension| extension.name == extension_name }
+      end
+    end
+  end
+end

data/lib/db_schema/definitions/table.rb

@@ -0,0 +1,115 @@
+module DbSchema
+  module Definitions
+    class Table
+      include Dry::Equalizer(:name, :fields, :indices, :checks, :foreign_keys)
+      attr_reader :name, :fields, :indices, :checks, :foreign_keys
+
+      def initialize(name, fields: [], indices: [], checks: [], foreign_keys: [])
+        @name         = name.to_sym
+        @fields       = fields
+        @indices      = indices
+        @checks       = checks
+        @foreign_keys = foreign_keys
+      end
+
+      def has_expressions?
+        fields.any?(&:default_is_expression?) ||
+          indices.any?(&:has_expressions?) ||
+          checks.any?
+      end
+
+      def field(field_name)
+        fields.find { |field| field.name == field_name } || NullField.new
+      end
+      alias_method :[], :field
+
+      def has_field?(field_name)
+        !field(field_name).is_a?(NullField)
+      end
+
+      def index(index_name)
+        indices.find { |index| index.name == index_name } || NullIndex.new
+      end
+
+      def has_index?(index_name)
+        !index(index_name).is_a?(NullIndex)
+      end
+
+      def has_index_on?(*field_names)
+        indices.any? do |index|
+          index.columns.none?(&:expression?) && index.columns.map(&:name) == field_names
+        end
+      end
+
+      def has_unique_index_on?(*field_names)
+        indices.any? do |index|
+          index.unique? && index.columns.none?(&:expression?) && index.columns.map(&:name) == field_names
+        end
+      end
+
+      def check(check_name)
+        checks.find { |check| check.name == check_name } || NullCheckConstraint.new
+      end
+
+      def has_check?(check_name)
+        !check(check_name).is_a?(NullCheckConstraint)
+      end
+
+      def foreign_key(fkey_name)
+        foreign_keys.find { |fkey| fkey.name == fkey_name } || NullForeignKey.new
+      end
+
+      def has_foreign_key?(fkey_name)
+        !foreign_key(fkey_name).is_a?(NullForeignKey)
+      end
+
+      def has_foreign_key_to?(other_table_name)
+        foreign_keys.any? { |fkey| fkey.table == other_table_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
+  end
+end

data/lib/db_schema/dsl.rb

@@ -1,16 +1,14 @@
+require_relative 'dsl/migration'
+
 module DbSchema
   class DSL
-    attr_reader :block
+    attr_reader :schema, :migrations
 
     def initialize(block)
-      @block  = block
-      @schema = Definitions::Schema.new
-    end
+      @schema     = Definitions::Schema.new
+      @migrations = []
 
-    def schema
       block.call(self)
-
-      @schema
     end
 
     def table(name, &block)
@@ -33,6 +31,10 @@ module DbSchema
       @schema.extensions << Definitions::Extension.new(name.to_sym)
     end
 
+    def migrate(name, &block)
+      migrations << Migration.new(name, block).migration
+    end
+
     class TableYielder
       attr_reader :table_name
 
@@ -61,47 +63,11 @@ module DbSchema
         field(name, :integer, primary_key: true)
       end
 
-      def index(*columns, name: nil, unique: false, using: :btree, where: nil, **ordered_fields)
-        if columns.last.is_a?(Hash)
-          *ascending_columns, ordered_expressions = columns
-        else
-          ascending_columns = columns
-          ordered_expressions = {}
-        end
-
-        columns_data = ascending_columns.each_with_object({}) do |column_name, columns|
-          columns[column_name] = :asc
-        end.merge(ordered_fields).merge(ordered_expressions)
-
-        index_columns = columns_data.map do |column_name, column_order_options|
-          options = case column_order_options
-          when :asc
-            {}
-          when :desc
-            { order: :desc }
-          when :asc_nulls_first
-            { nulls: :first }
-          when :desc_nulls_last
-            { order: :desc, nulls: :last }
-          else
-            raise ArgumentError, 'Only :asc, :desc, :asc_nulls_first and :desc_nulls_last options are supported.'
-          end
-
-          if column_name.is_a?(String)
-            Definitions::Index::Expression.new(column_name, **options)
-          else
-            Definitions::Index::TableField.new(column_name, **options)
-          end
-        end
-
-        index_name = name || "#{table_name}_#{index_columns.map(&:index_name_segment).join('_')}_index"
-
-        indices << Definitions::Index.new(
-          name:      index_name,
-          columns:   index_columns,
-          unique:    unique,
-          type:      using,
-          condition: where
+      def index(*columns, **index_options)
+        indices << TableYielder.build_index(
+          columns,
+          table_name: table_name,
+          **index_options
         )
       end
 
@@ -109,36 +75,15 @@ module DbSchema
         checks << Definitions::CheckConstraint.new(name: name, condition: condition)
       end
 
-      def foreign_key(*fkey_fields, references:, name: nil, on_update: :no_action, on_delete: :no_action, deferrable: false)
-        fkey_name = name || :"#{table_name}_#{fkey_fields.first}_fkey"
-
-        if references.is_a?(Array)
-          # [:table, :field]
-          referenced_table, *referenced_keys = references
-
-          foreign_keys << Definitions::ForeignKey.new(
-            name:       fkey_name,
-            fields:     fkey_fields,
-            table:      referenced_table,
-            keys:       referenced_keys,
-            on_delete:  on_delete,
-            on_update:  on_update,
-            deferrable: deferrable
-          )
-        else
-          # :table
-          foreign_keys << Definitions::ForeignKey.new(
-            name:       fkey_name,
-            fields:     fkey_fields,
-            table:      references,
-            on_delete:  on_delete,
-            on_update:  on_update,
-            deferrable: deferrable
-          )
-        end
+      def foreign_key(*fkey_fields, **fkey_options)
+        foreign_keys << TableYielder.build_foreign_key(
+          fkey_fields,
+          table_name: table_name,
+          **fkey_options
+        )
       end
 
-      def field(name, type, custom: false, unique: false, index: false, references: nil, check: nil, **options)
+      def field(name, type, unique: false, index: false, references: nil, check: nil, **options)
         fields << Definitions::Field.build(name, type, options)
 
         if unique
@@ -171,6 +116,81 @@ module DbSchema
       def foreign_keys
         @foreign_keys ||= []
       end
+
+      class << self
+        def build_index(columns, table_name:, name: nil, unique: false, using: :btree, where: nil, **ordered_fields)
+          if columns.last.is_a?(Hash)
+            *ascending_columns, ordered_expressions = columns
+          else
+            ascending_columns = columns
+            ordered_expressions = {}
+          end
+
+          columns_data = ascending_columns.each_with_object({}) do |column_name, columns|
+            columns[column_name] = :asc
+          end.merge(ordered_fields).merge(ordered_expressions)
+
+          index_columns = columns_data.map do |column_name, column_order_options|
+            options = case column_order_options
+            when :asc
+              {}
+            when :desc
+              { order: :desc }
+            when :asc_nulls_first
+              { nulls: :first }
+            when :desc_nulls_last
+              { order: :desc, nulls: :last }
+            else
+              raise ArgumentError, 'Only :asc, :desc, :asc_nulls_first and :desc_nulls_last options are supported.'
+            end
+
+            if column_name.is_a?(String)
+              Definitions::Index::Expression.new(column_name, **options)
+            else
+              Definitions::Index::TableField.new(column_name, **options)
+            end
+          end
+
+          index_name = name || "#{table_name}_#{index_columns.map(&:index_name_segment).join('_')}_index"
+
+          Definitions::Index.new(
+            name:      index_name,
+            columns:   index_columns,
+            unique:    unique,
+            type:      using,
+            condition: where
+          )
+        end
+
+        def build_foreign_key(fkey_fields, table_name:, references:, name: nil, on_update: :no_action, on_delete: :no_action, deferrable: false)
+          fkey_name = name || :"#{table_name}_#{fkey_fields.first}_fkey"
+
+          if references.is_a?(Array)
+            # [:table, :field]
+            referenced_table, *referenced_keys = references
+
+            Definitions::ForeignKey.new(
+              name:       fkey_name,
+              fields:     fkey_fields,
+              table:      referenced_table,
+              keys:       referenced_keys,
+              on_delete:  on_delete,
+              on_update:  on_update,
+              deferrable: deferrable
+            )
+          else
+            # :table
+            Definitions::ForeignKey.new(
+              name:       fkey_name,
+              fields:     fkey_fields,
+              table:      references,
+              on_delete:  on_delete,
+              on_update:  on_update,
+              deferrable: deferrable
+            )
+          end
+        end
+      end
     end
   end
 end

data/lib/db_schema/dsl/migration.rb

@@ -0,0 +1,24 @@
+module DbSchema
+  class DSL
+    class Migration
+      attr_reader :migration
+
+      def initialize(name, block)
+        @migration = DbSchema::Migration.new(name)
+        block.call(self)
+      end
+
+      def apply_if(&block)
+        migration.conditions[:apply] << block
+      end
+
+      def skip_if(&block)
+        migration.conditions[:skip] << block
+      end
+
+      def run(&block)
+        migration.body = block
+      end
+    end
+  end
+end