db_schema 0.2.5 → 0.3.rc1

data/lib/db_schema/configuration.rb

@@ -1,29 +1,48 @@
+require 'dry/equalizer'
+
 module DbSchema
   class Configuration
-    attr_reader :adapter, :host, :port, :database, :user, :password
-
-    def initialize(adapter: 'postgres', host: 'localhost', port: 5432, database:, user: nil, password: '', log_changes: true, dry_run: false, post_check: true)
-      @adapter     = adapter
-      @host        = host
-      @port        = port
-      @database    = database
-      @user        = user
-      @password    = password
-      @log_changes = log_changes
-      @dry_run     = dry_run
-      @post_check  = post_check
+    include Dry::Equalizer(:params)
+
+    DEFAULT_VALUES = {
+      adapter:     'postgres',
+      host:        'localhost',
+      port:        5432,
+      database:    nil,
+      user:        nil,
+      password:    '',
+      log_changes: true,
+      dry_run:     false,
+      post_check:  true
+    }.freeze
+
+    def initialize(params = {})
+      @params = DEFAULT_VALUES.merge(params)
+    end
+
+    def merge(new_params)
+      Configuration.new(@params.merge(new_params))
+    end
+
+    [:adapter, :host, :port, :database, :user, :password].each do |param_name|
+      define_method(param_name) do
+        @params[param_name]
+      end
     end
 
     def log_changes?
-      @log_changes
+      @params[:log_changes]
     end
 
     def dry_run?
-      @dry_run
+      @params[:dry_run]
     end
 
     def post_check_enabled?
-      @post_check
+      @params[:post_check]
     end
+
+  protected
+    attr_reader :params
   end
 end

data/lib/db_schema/definitions.rb

@@ -1,255 +1,10 @@
 require 'dry/equalizer'
 
-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_name)
-        tables.find { |table| table.name == table_name } || NullTable.new
-      end
-    end
-
-    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_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
-      include Dry::Equalizer(:name, :columns, :unique?, :type, :condition)
-      attr_reader :name, :columns, :type, :condition
-
-      def initialize(name:, columns:, unique: false, type: :btree, condition: nil)
-        @name      = name.to_sym
-        @columns   = columns
-        @unique    = unique
-        @type      = type
-        @condition = condition
-      end
-
-      def unique?
-        @unique
-      end
-
-      def btree?
-        type == :btree
-      end
-
-      def columns_to_sequel
-        if btree?
-          columns.map(&:ordered_expression)
-        else
-          columns.map(&:to_sequel)
-        end
-      end
-
-      def has_expressions?
-        !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
-
-        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
-
-      class TableField < Column
-        def expression?
-          false
-        end
-
-        def index_name_segment
-          name
-        end
-
-        def to_sequel
-          name
-        end
-      end
-
-      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
-
-    class ForeignKey
-      include Dry::Equalizer(:name, :fields, :table, :keys, :on_update, :on_delete, :deferrable?)
-      attr_reader :name, :fields, :table, :keys, :on_update, :on_delete
-
-      def initialize(name:, fields:, table:, keys: [], on_update: :no_action, on_delete: :no_action, deferrable: false)
-        @name       = name
-        @fields     = fields
-        @table      = table
-        @keys       = keys
-        @on_update  = on_update
-        @on_delete  = on_delete
-        @deferrable = deferrable
-      end
-
-      def references_primary_key?
-        keys.empty?
-      end
-
-      def deferrable?
-        @deferrable
-      end
-
-      def options
-        {
-          deferrable: deferrable?,
-          name:       name,
-          on_delete:  on_delete,
-          on_update:  on_update
-        }.tap do |options|
-          options[:key] = keys unless references_primary_key?
-        end
-      end
-    end
-
-    class CheckConstraint
-      include Dry::Equalizer(:name, :condition)
-      attr_reader :name, :condition
-
-      def initialize(name:, condition:)
-        @name      = name.to_sym
-        @condition = condition
-      end
-    end
-
-    class Enum
-      include Dry::Equalizer(:name, :values)
-      attr_reader :name, :values
-
-      def initialize(name, values)
-        @name   = name
-        @values = values
-      end
-
-      def with_name(new_name)
-        Enum.new(new_name, values)
-      end
-    end
-
-    class Extension
-      include Dry::Equalizer(:name)
-      attr_reader :name
-
-      def initialize(name)
-        @name = name
-      end
-    end
-  end
-end
-
+require_relative 'definitions/schema'
+require_relative 'definitions/table'
 require_relative 'definitions/field'
+require_relative 'definitions/index'
+require_relative 'definitions/foreign_key'
+require_relative 'definitions/check_constraint'
+require_relative 'definitions/enum'
+require_relative 'definitions/extension'

data/lib/db_schema/definitions/check_constraint.rb

@@ -0,0 +1,17 @@
+module DbSchema
+  module Definitions
+    class CheckConstraint
+      include Dry::Equalizer(:name, :condition)
+      attr_reader :name, :condition
+
+      def initialize(name:, condition:)
+        @name      = name.to_sym
+        @condition = condition
+      end
+    end
+
+    class NullCheckConstraint < CheckConstraint
+      def initialize; end
+    end
+  end
+end

data/lib/db_schema/definitions/enum.rb

@@ -0,0 +1,21 @@
+module DbSchema
+  module Definitions
+    class Enum
+      include Dry::Equalizer(:name, :values)
+      attr_reader :name, :values
+
+      def initialize(name, values)
+        @name   = name
+        @values = values
+      end
+
+      def with_name(new_name)
+        Enum.new(new_name, values)
+      end
+    end
+
+    class NullEnum < Enum
+      def initialize; end
+    end
+  end
+end

data/lib/db_schema/definitions/extension.rb

@@ -0,0 +1,12 @@
+module DbSchema
+  module Definitions
+    class Extension
+      include Dry::Equalizer(:name)
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+    end
+  end
+end

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

@@ -94,5 +94,11 @@ module DbSchema
         end
       end
     end
+
+    class NullField < Field::Base
+      def initialize
+        super(nil)
+      end
+    end
   end
 end

data/lib/db_schema/definitions/foreign_key.rb

@@ -0,0 +1,41 @@
+module DbSchema
+  module Definitions
+    class ForeignKey
+      include Dry::Equalizer(:name, :fields, :table, :keys, :on_update, :on_delete, :deferrable?)
+      attr_reader :name, :fields, :table, :keys, :on_update, :on_delete
+
+      def initialize(name:, fields:, table:, keys: [], on_update: :no_action, on_delete: :no_action, deferrable: false)
+        @name       = name
+        @fields     = fields
+        @table      = table
+        @keys       = keys
+        @on_update  = on_update
+        @on_delete  = on_delete
+        @deferrable = deferrable
+      end
+
+      def references_primary_key?
+        keys.empty?
+      end
+
+      def deferrable?
+        @deferrable
+      end
+
+      def options
+        {
+          deferrable: deferrable?,
+          name:       name,
+          on_delete:  on_delete,
+          on_update:  on_update
+        }.tap do |options|
+          options[:key] = keys unless references_primary_key?
+        end
+      end
+    end
+
+    class NullForeignKey < ForeignKey
+      def initialize; end
+    end
+  end
+end

data/lib/db_schema/definitions/index.rb

@@ -0,0 +1,56 @@
+module DbSchema
+  module Definitions
+    class Index
+      include Dry::Equalizer(:name, :columns, :unique?, :type, :condition)
+      attr_reader :name, :columns, :type, :condition
+
+      def initialize(name:, columns:, unique: false, type: :btree, condition: nil)
+        @name      = name.to_sym
+        @columns   = columns
+        @unique    = unique
+        @type      = type
+        @condition = condition
+      end
+
+      def unique?
+        @unique
+      end
+
+      def btree?
+        type == :btree
+      end
+
+      def columns_to_sequel
+        if btree?
+          columns.map(&:ordered_expression)
+        else
+          columns.map(&:to_sequel)
+        end
+      end
+
+      def has_expressions?
+        !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
+    end
+
+    class NullIndex < Index
+      def initialize
+        @columns = []
+      end
+    end
+  end
+end
+
+require_relative 'index/column'
+require_relative 'index/table_field'
+require_relative 'index/expression'