rom-sql 2.0.0.beta2 → 2.0.0.beta3

data/lib/rom/sql/migration/recorder.rb

@@ -0,0 +1,21 @@
+module ROM
+  module SQL
+    module Migration
+      # @api private
+      class Recorder
+        attr_reader :operations
+
+        def initialize(&block)
+          @operations = []
+
+          instance_exec(&block) if block
+        end
+
+        def method_missing(m, *args, &block)
+          nested = block ? Recorder.new(&block).operations : EMPTY_ARRAY
+          @operations << [m, args, nested]
+        end
+      end
+    end
+  end
+end

data/lib/rom/sql/migration/runner.rb

@@ -0,0 +1,115 @@
+module ROM
+  module SQL
+    module Migration
+      # @api private
+      class Runner
+        attr_reader :writer
+
+        def initialize(writer)
+          @writer = writer
+        end
+
+        def call(changes)
+          changes.each { |diff| apply_schema(diff) }
+          changes.each { |diff| apply_constraints(diff) }
+
+          self
+        end
+
+        def apply_schema(diff)
+          case diff
+          when SchemaDiff::TableCreated
+            create_table(diff)
+          when SchemaDiff::TableAltered
+            alter_table(diff)
+          end
+        end
+
+        def apply_constraints(diff)
+          case diff
+          when SchemaDiff::TableCreated
+            alter_foreign_keys(diff, diff.foreign_keys)
+          when SchemaDiff::TableAltered
+            alter_foreign_keys(diff, diff.foreign_key_changes)
+          end
+        end
+
+        def create_table(diff)
+          writer.migration do |connection|
+            connection.create_table(diff.table_name) do
+              diff.attributes.each do |attribute|
+                if attribute.primary_key?
+                  primary_key attribute.name
+                else
+                  column attribute.name, attribute.type, null: attribute.null?
+                end
+              end
+
+              diff.indexes.each do |index|
+                index index.attributes, index.options
+              end
+            end
+          end
+        end
+
+        def alter_table(diff)
+          return if diff.meta?
+
+          writer.migration do |connection|
+            connection.alter_table(diff.table_name) do
+              diff.attribute_changes.each do |attribute|
+                case attribute
+                when SchemaDiff::AttributeAdded
+                  add_column attribute.name, attribute.type, null: attribute.null?
+                when SchemaDiff::AttributeRemoved
+                  drop_column attribute.name
+                when SchemaDiff::AttributeChanged
+                  if attribute.type_changed?
+                    from, to = attribute.current.unwrap, attribute.target.unwrap
+                    raise UnsupportedConversion.new(
+                            "Don't know how to convert #{ from.inspect } to #{ to.inspect }"
+                          )
+                  end
+
+                  if attribute.nullability_changed?
+                    if attribute.null?
+                      set_column_allow_null attribute.name
+                    else
+                      set_column_not_null attribute.name
+                    end
+                  end
+                end
+              end
+
+              diff.index_changes.each do |index|
+                case index
+                when SchemaDiff::IndexAdded
+                  add_index index.attributes, index.options
+                when SchemaDiff::IndexRemoved
+                  drop_index index.attributes, index.options
+                end
+              end
+            end
+          end
+        end
+
+        def alter_foreign_keys(diff, foreign_key_changes)
+          return if foreign_key_changes.empty?
+
+          writer.migration do |connection|
+            connection.alter_table(diff.table_name) do
+              foreign_key_changes.map do |fk|
+                case fk
+                when SchemaDiff::ForeignKeyAdded
+                  add_foreign_key fk.child_keys, fk.parent
+                when SchemaDiff::ForeignKeyRemoved
+                  drop_foreign_key fk.child_keys
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/sql/migration/schema_diff.rb

@@ -1,14 +1,22 @@
+require 'rom/sql/type_serializer'
+
 module ROM
   module SQL
     module Migration
+      # @api private
       class SchemaDiff
+        extend Initializer
+
+        param :database_type
+
+        option :type_serializer, default: -> { ROM::SQL::TypeSerializer[database_type] }
+
         class TableDiff
-          attr_reader :current_schema, :target_schema
+          extend Initializer
 
-          def initialize(current_schema: nil, target_schema: nil)
-            @current_schema = current_schema
-            @target_schema = target_schema
-          end
+          option :current_schema, optional: true
+
+          option :target_schema, optional: true
 
           def empty?
             false
@@ -27,33 +35,33 @@ module ROM
 
         class TableCreated < TableDiff
           alias_method :schema, :target_schema
-          attr_reader :attributes, :indexes
 
-          def initialize(attributes:, indexes: EMPTY_ARRAY, **rest)
-            super(rest)
+          option :attributes
 
-            @attributes = attributes
-            @indexes = indexes
-          end
+          option :indexes, default: -> { EMPTY_ARRAY }
+
+          option :foreign_keys, default: -> { EMPTY_ARRAY }
         end
 
         class TableAltered < TableDiff
-          attr_reader :attribute_changes, :index_changes
 
-          def initialize(attribute_changes: EMPTY_ARRAY, index_changes: EMPTY_ARRAY, **rest)
-            super(rest)
+          option :attribute_changes, default: -> { EMPTY_ARRAY }
+
+          option :index_changes, default: -> { EMPTY_ARRAY }
 
-            @attribute_changes = attribute_changes
-            @index_changes = index_changes
+          option :foreign_key_changes, default: -> { EMPTY_ARRAY }
+
+          def meta?
+            attribute_changes.empty? && index_changes.empty?
           end
         end
 
         class AttributeDiff
-          attr_reader :attr
+          extend Initializer
 
-          def initialize(attr)
-            @attr = attr
-          end
+          param :attr
+
+          option :type_serializer
 
           def name
             attr.name
@@ -74,7 +82,7 @@ module ROM
 
         class AttributeAdded < AttributeDiff
           def type
-            unwrap(attr).primitive
+            type_serializer.(unwrap(attr).type)
           end
         end
 
@@ -82,25 +90,21 @@ module ROM
         end
 
         class AttributeChanged < AttributeDiff
-          attr_reader :current
+          param :current
           alias_method :target, :attr
 
-          def initialize(current, target)
-            super(target)
-
-            @current = current
-          end
-
-          def to_a
-            [current, target]
-          end
-
           def nullability_changed?
             current.optional? ^ target.optional?
           end
 
           def type_changed?
-            unwrap(current).meta(index: Set.new) != unwrap(target).meta(index: Set.new)
+            clean(current.qualified) != clean(target.qualified)
+          end
+
+          private
+
+          def clean(type)
+            unwrap(type).meta(index: nil, foreign_key: nil, target: nil)
           end
         end
 
@@ -112,55 +116,87 @@ module ROM
           end
 
           def attributes
-            index.attributes.map(&:name)
+            list = index.attributes.map(&:name)
+
+            if list.size == 1
+              list[0]
+            else
+              list
+            end
           end
 
           def name
             index.name
           end
+        end
 
-          def unique?
-            index.unique?
+        class IndexAdded < IndexDiff
+          def options
+            options = {}
+            options[:name] = index.name if !index.name.nil?
+            options[:unique] = true if index.unique?
+            options[:type] = index.type if !index.type.nil?
+            options[:where] = index.predicate if !index.predicate.nil?
+            options
           end
+        end
 
-          def type
-            index.type
+        class IndexRemoved < IndexDiff
+          def options
+            options = {}
+            options[:name] = index.name if !index.name.nil?
+            options
+          end
+        end
+
+        class ForeignKeyDiff
+          attr_reader :foreign_key
+
+          def initialize(foreign_key)
+            @foreign_key = foreign_key
+          end
+
+          def parent
+            foreign_key.parent_table
           end
 
-          def predicate
-            index.predicate
+          def parent_keys
+            foreign_key.parent_keys
           end
 
-          def partial?
-            !predicate.nil?
+          def child_keys
+            foreign_key.attributes.map(&:name)
           end
         end
 
-        class IndexAdded < IndexDiff
+        class ForeignKeyAdded < ForeignKeyDiff
         end
 
-        class IndexRemoved < IndexDiff
+        class ForeignKeyRemoved < ForeignKeyDiff
         end
 
         def call(current, target)
           if current.empty?
             TableCreated.new(
               target_schema: target,
-              attributes: target.map { |attr| AttributeAdded.new(attr) },
-              indexes: target.indexes.map { |idx| IndexAdded.new(idx) }
+              attributes: map_attributes(target.to_h, AttributeAdded),
+              indexes: target.indexes.map { |idx| IndexAdded.new(idx) },
+              foreign_keys: target.foreign_keys.map { |fk| ForeignKeyAdded.new(fk) }
             )
           else
             attribute_changes = compare_attributes(current.to_h, target.to_h)
             index_changes = compare_indexes(current, target)
+            fk_changes = compare_foreign_key_constraints(current, target)
 
-            if attribute_changes.empty? && index_changes.empty?
+            if attribute_changes.empty? && index_changes.empty? && fk_changes.empty?
               Empty.new(current_schema: current, target_schema: target)
             else
               TableAltered.new(
                 current_schema: current,
                 target_schema: target,
                 attribute_changes: attribute_changes,
-                index_changes: index_changes
+                index_changes: index_changes,
+                foreign_key_changes: fk_changes
               )
             end
           end
@@ -168,16 +204,16 @@ module ROM
 
         def compare_attributes(current, target)
           changed_attributes = target.select { |name, attr|
-            current.key?(name) && current[name] != attr
+            current.key?(name) && !attributes_equal?(current[name], attr)
           }.map { |name, target_attr|
-            [name, [current[name], target_attr]]
+            [name, [target_attr, current[name]]]
           }.to_h
           added_attributes = target.select { |name, _| !current.key?(name) }
           removed_attributes = current.select { |name, _| !target.key?(name) }
 
-          removed_attributes.values.map { |attr| AttributeRemoved.new(attr) } +
-            added_attributes.values.map { |attr| AttributeAdded.new(attr) } +
-            changed_attributes.values.map { |attrs| AttributeChanged.new(*attrs) }
+          map_attributes(removed_attributes, AttributeRemoved) +
+            map_attributes(added_attributes, AttributeAdded) +
+            map_attributes(changed_attributes, AttributeChanged)
         end
 
         def compare_indexes(current, target)
@@ -191,6 +227,25 @@ module ROM
           removed_indexes.map { |idx| IndexRemoved.new(idx) } +
             added_indexes.map { |idx| IndexAdded.new(idx) }
         end
+
+        def compare_foreign_key_constraints(current, target)
+          target_fks = target.foreign_keys
+          current_fks = current.foreign_keys
+
+          added_fks = target_fks - current_fks
+          removed_fks = current_fks - target_fks
+
+          removed_fks.map { |fk| ForeignKeyRemoved.new(fk) } +
+            added_fks.map { |fk| ForeignKeyAdded.new(fk) }
+        end
+
+        def attributes_equal?(a, b)
+          a.qualified == b.qualified
+        end
+
+        def map_attributes(attributes, change_type)
+          attributes.values.map { |args| change_type.new(*args, type_serializer: type_serializer) }
+        end
       end
     end
   end

data/lib/rom/sql/migration/writer.rb

@@ -0,0 +1,61 @@
+require 'rom/sql/migration/recorder'
+
+module ROM
+  module SQL
+    module Migration
+      # @api private
+      class Writer
+        MIGRATION_BEGIN = "ROM::SQL.migration do\n  change do".freeze
+        MIGRATION_END = "\n  end\nend\n".freeze
+
+        attr_reader :yield_migration
+
+        def initialize(&block)
+          @yield_migration = block
+        end
+
+        def migration
+          recorder = Recorder.new
+          yield(recorder)
+          yield_migration.(create_migration(recorder.operations))
+        end
+
+        def create_migration(ops)
+          out = MIGRATION_BEGIN.dup
+          write(ops, out, "\n    ")
+          out << MIGRATION_END
+
+          [migration_name(ops[0]), out]
+        end
+
+        def write(operations, buffer, indent)
+          operations.each do |operation|
+            op, args, nested = operation
+            buffer << indent << op.to_s << ' '
+            write_arguments(buffer, *args)
+
+            if !nested.empty?
+              buffer << ' do'
+              write(nested, buffer, indent + '  ')
+              buffer << indent << 'end'
+            end
+          end
+        end
+
+        def write_arguments(buffer, *args, **kwargs)
+          buffer << args.map(&:inspect).join(', ')
+          kwargs.each do |key, value|
+            buffer << ', ' << key.to_s << ': ' << value.inspect
+          end
+        end
+
+        def migration_name(op)
+          create_or_alter, args = op
+          table_name = args[0]
+
+          "#{ create_or_alter.to_s.sub('_table', '') }_#{ table_name }"
+        end
+      end
+    end
+  end
+end