db_schema 0.3.1 → 0.4

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

@@ -1,19 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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

@@ -1,130 +0,0 @@
-module DbSchema
-  module Definitions
-    class Table
-      include Dry::Equalizer(:name, :fields, :indexes, :checks, :foreign_keys)
-      attr_reader :name, :fields, :indexes, :checks, :foreign_keys
-
-      def initialize(name, fields: [], indexes: [], checks: [], foreign_keys: [])
-        @name         = name.to_sym
-        @fields       = fields
-        @indexes      = indexes
-        @checks       = checks
-        @foreign_keys = foreign_keys
-      end
-
-      def has_expressions?
-        fields.any?(&:default_is_expression?) ||
-          indexes.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)
-        indexes.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)
-        indexes.any? do |index|
-          index.columns.none?(&:expression?) && index.columns.map(&:name) == field_names
-        end
-      end
-
-      def has_unique_index_on?(*field_names)
-        indexes.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,
-          indexes:      indexes,
-          checks:       checks,
-          foreign_keys: foreign_keys
-        )
-      end
-
-      def with_fields(new_fields)
-        Table.new(
-          name,
-          fields:       new_fields,
-          indexes:      indexes,
-          checks:       checks,
-          foreign_keys: foreign_keys
-        )
-      end
-
-      def with_indexes(new_indexes)
-        Table.new(
-          name,
-          fields:       fields,
-          indexes:      new_indexes,
-          checks:       checks,
-          foreign_keys: foreign_keys
-        )
-      end
-
-      def with_checks(new_checks)
-        Table.new(
-          name,
-          fields:       fields,
-          indexes:      indexes,
-          checks:       new_checks,
-          foreign_keys: foreign_keys
-        )
-      end
-
-      def with_foreign_keys(new_foreign_keys)
-        Table.new(
-          name,
-          fields:       fields,
-          indexes:      indexes,
-          checks:       checks,
-          foreign_keys: new_foreign_keys
-        )
-      end
-    end
-
-    class NullTable < Table
-      def initialize
-        @fields       = []
-        @indexes      = []
-        @checks       = []
-        @foreign_keys = []
-      end
-    end
-  end
-end