declare_schema 0.6.2 → 0.8.0.pre.1

data/lib/declare_schema/model/foreign_key_definition.rb

@@ -5,21 +5,21 @@ module DeclareSchema
     class ForeignKeyDefinition
       include Comparable
 
-      attr_reader :constraint_name, :model, :foreign_key, :options, :on_delete_cascade
+      attr_reader :constraint_name, :model, :foreign_key, :foreign_key_name, :options, :on_delete_cascade
 
       def initialize(model, foreign_key, options = {})
         @model = model
-        @foreign_key = foreign_key.presence
+        @foreign_key = foreign_key.to_s.presence
         @options = options
 
         @child_table = model.table_name # unless a table rename, which would happen when a class is renamed??
-        @parent_table_name = options[:parent_table]
-        @foreign_key_name = options[:foreign_key] || self.foreign_key
-        @index_name = options[:index_name] || model.connection.index_name(model.table_name, column: foreign_key)
-        @constraint_name = options[:constraint_name] || @index_name || ''
-        @on_delete_cascade = options[:dependent] == :delete
+        @parent_table_name = options[:parent_table]&.to_s
+        @foreign_key_name = options[:foreign_key]&.to_s || @foreign_key
+        @index_name = options[:index_name]&.to_s || model.connection.index_name(model.table_name, column: @foreign_key_name)
 
         # Empty constraint lets mysql generate the name
+        @constraint_name = options[:constraint_name]&.to_s || @index_name&.to_s || ''
+        @on_delete_cascade = options[:dependent] == :delete
       end
 
       class << self
@@ -28,11 +28,12 @@ module DeclareSchema
           constraints = show_create_table.split("\n").map { |line| line.strip if line['CONSTRAINT'] }.compact
 
           constraints.map do |fkc|
-            options = {}
             name, foreign_key, parent_table = fkc.match(/CONSTRAINT `([^`]*)` FOREIGN KEY \(`([^`]*)`\) REFERENCES `([^`]*)`/).captures
-            options[:constraint_name] = name
-            options[:parent_table] = parent_table
-            options[:foreign_key] = foreign_key
+            options = {
+              constraint_name: name,
+              parent_table:    parent_table,
+              foreign_key:     foreign_key
+            }
             options[:dependent] = :delete if fkc['ON DELETE CASCADE']
 
             new(model, foreign_key, options)
@@ -40,21 +41,37 @@ module DeclareSchema
         end
       end
 
+      # returns the parent class as a Class object
+      # or nil if no :class_name option given
+      def parent_class
+        if (class_name = options[:class_name])
+          if class_name.is_a?(Class)
+            class_name
+          else
+            class_name.to_s.constantize
+          end
+        end
+      end
+
       def parent_table_name
         @parent_table_name ||=
-          if (klass = options[:class_name])
-            klass = klass.to_s.constantize unless klass.is_a?(Class)
-            klass.try(:table_name)
-          end || foreign_key.sub(/_id\z/, '').camelize.constantize.table_name
+          parent_class&.try(:table_name) ||
+            foreign_key.sub(/_id\z/, '').camelize.constantize.table_name
       end
 
-      attr_writer :parent_table_name
+      def to_add_statement
+        "add_foreign_key(#{@child_table.inspect}, #{parent_table_name.inspect}, " +
+          "column: #{@foreign_key_name.inspect}, name: #{@constraint_name.inspect})"
+      end
 
-      def to_add_statement(_new_table_name = nil, _existing_primary_key = nil)
-        statement = "ALTER TABLE #{@child_table} ADD CONSTRAINT #{@constraint_name} FOREIGN KEY #{@index_name}(#{@foreign_key_name}) REFERENCES #{parent_table_name}(id) #{'ON DELETE CASCADE' if on_delete_cascade}"
-        "execute #{statement.inspect}"
+      def <=>(rhs)
+        key <=> rhs.send(:key)
       end
 
+      alias eql? ==
+
+      private
+
       def key
         @key ||= [@child_table, parent_table_name, @foreign_key_name, @on_delete_cascade].map(&:to_s)
       end
@@ -62,12 +79,6 @@ module DeclareSchema
       def hash
         key.hash
       end
-
-      def <=>(rhs)
-        key <=> rhs.key
-      end
-
-      alias eql? ==
     end
   end
 end

data/lib/declare_schema/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DeclareSchema
-  VERSION = "0.6.2"
+  VERSION = "0.8.0.pre.1"
 end

data/lib/generators/declare_schema/migration/migration_generator.rb

@@ -96,7 +96,7 @@ module DeclareSchema
           end
         end
       end
-    rescue ::DeclareSchema::Model::FieldSpec::UnknownSqlTypeError => ex
+    rescue ::DeclareSchema::UnknownTypeError => ex
       say "Invalid field type: #{ex}"
     end
 

data/lib/generators/declare_schema/migration/migrator.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'active_record'
+require 'active_record/connection_adapters/abstract_adapter'
 
 module Generators
   module DeclareSchema
@@ -116,20 +117,6 @@ module Generators
             ActiveRecord::Base.connection
           end
 
-          def fix_native_types(types)
-            case connection.class.name
-            when /mysql/i
-              types[:integer][:limit] ||= 11
-              types[:text][:limit]    ||= 0xffff
-              types[:binary][:limit]  ||= 0xffff
-            end
-            types
-          end
-
-          def native_types
-            @native_types ||= fix_native_types(connection.native_database_types)
-          end
-
           def before_generating_migration(&block)
             block or raise ArgumentError, 'A block is required when setting the before_generating_migration callback'
             @before_generating_migration_callback = block
@@ -299,7 +286,7 @@ module Generators
             "drop_table :#{t}"
           end * "\n"
           undo_drops = to_drop.map do |t|
-            revert_table(t)
+            add_table_back(t)
           end * "\n\n"
 
           creates = to_create.map do |t|
@@ -341,11 +328,11 @@ module Generators
         end
 
         def create_table(model)
-          longest_field_name       = model.field_specs.values.map { |f| f.sql_type.to_s.length }.max
+          longest_field_name       = model.field_specs.values.map { |f| f.type.to_s.length }.max
           disable_auto_increment   = model.respond_to?(:disable_auto_increment) && model.disable_auto_increment
           table_options_definition = ::DeclareSchema::Model::TableOptionsDefinition.new(model.table_name, table_options_for_model(model))
           field_definitions        = [
-            disable_auto_increment ? "t.integer :id, limit: 8, auto_increment: false, primary_key: true" : nil,
+            ("t.integer :id, limit: 8, auto_increment: false, primary_key: true" if disable_auto_increment),
             *(model.field_specs.values.sort_by(&:position).map { |f| create_field(f, longest_field_name) })
           ].compact
 
@@ -386,13 +373,13 @@ module Generators
         end
 
         def create_constraints(model)
-          model.constraint_specs.map { |fk| fk.to_add_statement(model.table_name) }
+          model.constraint_specs.map { |fk| fk.to_add_statement }
         end
 
         def create_field(field_spec, field_name_width)
-          options = fk_field_options(field_spec.model, field_spec.name).merge(field_spec.sql_options)
-          args = [field_spec.name.inspect] + format_options(options, field_spec.sql_type)
-          format("t.%-*s %s", field_name_width, field_spec.sql_type, args.join(', '))
+          options = field_spec.sql_options.merge(fk_field_options(field_spec.model, field_spec.name))
+          args = [field_spec.name.inspect] + format_options(options.compact)
+          format("t.%-*s %s", field_name_width, field_spec.type, args.join(', '))
         end
 
         def change_table(model, current_table_name)
@@ -429,8 +416,8 @@ module Generators
           adds = to_add.map do |c|
             args =
               if (spec = model.field_specs[c])
-                options = fk_field_options(model, c).merge(spec.sql_options)
-                [":#{spec.sql_type}", *format_options(options, spec.sql_type)]
+                options = spec.sql_options.merge(fk_field_options(model, c))
+                [":#{spec.type}", *format_options(options.compact)]
               else
                 [":integer"]
               end
@@ -444,34 +431,28 @@ module Generators
             "remove_column :#{new_table_name}, :#{c}"
           end
           undo_removes = to_remove.map do |c|
-            revert_column(current_table_name, c)
+            add_column_back(model, current_table_name, c)
           end
 
           old_names = to_rename.invert
           changes = []
           undo_changes = []
-          to_change.each do |c|
-            col_name = old_names[c] || c
-            col = db_columns[col_name]
-            spec = model.field_specs[c]
-            if spec.different_to?(current_table_name, col) # TODO: TECH-4814 DRY this up to a diff function that returns the differences. It's different if it has differences. -Colin
-              change_spec = fk_field_options(model, c)
-              change_spec[:limit]     ||= spec.limit   if (spec.sql_type != :text ||
-                                                         ::DeclareSchema::Model::FieldSpec.mysql_text_limits?) &&
-                                                          (spec.limit || col.limit)
-              change_spec[:precision]     = spec.precision     unless spec.precision.nil?
-              change_spec[:scale]         = spec.scale         unless spec.scale.nil?
-              change_spec[:null]          = spec.null          unless spec.null && col.null
-              change_spec[:default]       = spec.default       unless spec.default.nil? && col.default.nil?
-              change_spec[:charset]       = spec.charset       unless spec.charset.nil?
-              change_spec[:collation]     = spec.collation     unless spec.collation.nil?
-
-              changes << "change_column :#{new_table_name}, :#{c}, " +
-                         ([":#{spec.sql_type}"] + format_options(change_spec, spec.sql_type, changing: true)).join(", ")
-              back = change_column_back(current_table_name, col_name)
-              undo_changes << back unless back.blank?
+          to_change.each do |col_name_to_change|
+            orig_col_name      = old_names[col_name_to_change] || col_name_to_change
+            column             = db_columns[orig_col_name] or raise "failed to find column info for #{orig_col_name.inspect}"
+            spec               = model.field_specs[col_name_to_change] or raise "failed to find field spec for #{col_name_to_change.inspect}"
+            spec_attrs         = spec.schema_attributes(column)
+            column_declaration = ::DeclareSchema::Model::Column.new(model, current_table_name, column)
+            col_attrs          = column_declaration.schema_attributes
+            normalized_schema_attrs = spec_attrs.merge(fk_field_options(model, col_name_to_change))
+
+            if !::DeclareSchema::Model::Column.equivalent_schema_attributes?(normalized_schema_attrs, col_attrs)
+              type = normalized_schema_attrs.delete(:type) or raise "no :type found in #{normalized_schema_attrs.inspect}"
+              changes << ["change_column #{new_table_name.to_sym.inspect}", col_name_to_change.to_sym.inspect,
+                          type.to_sym.inspect, *format_options(normalized_schema_attrs)].join(", ")
+              undo_changes << change_column_back(model, current_table_name, orig_col_name)
             end
-          end.compact
+          end
 
           index_changes, undo_index_changes = change_indexes(model, current_table_name, to_remove)
           fk_changes, undo_fk_changes = if ActiveRecord::Base.connection.class.name.match?(/SQLite3Adapter/)
@@ -485,26 +466,26 @@ module Generators
                                                                 [[], []]
                                                               end
 
-          [(renames + adds + removes + changes) * "\n",
+          [(renames + adds + removes + changes)                     * "\n",
            (undo_renames + undo_adds + undo_removes + undo_changes) * "\n",
-           index_changes * "\n",
-           undo_index_changes * "\n",
-           fk_changes * "\n",
-           undo_fk_changes * "\n",
-           table_options_changes * "\n",
-           undo_table_options_changes * "\n"]
+           index_changes                                            * "\n",
+           undo_index_changes                                       * "\n",
+           fk_changes                                               * "\n",
+           undo_fk_changes                                          * "\n",
+           table_options_changes                                    * "\n",
+           undo_table_options_changes                               * "\n"]
         end
 
         def change_indexes(model, old_table_name, to_remove)
-          return [[], []] if Migrator.disable_constraints
+          Migrator.disable_constraints and return [[], []]
 
           new_table_name = model.table_name
           existing_indexes = ::DeclareSchema::Model::IndexDefinition.for_model(model, old_table_name)
           model_indexes_with_equivalents = model.index_definitions_with_primary_key
           model_indexes = model_indexes_with_equivalents.map do |i|
             if i.explicit_name.nil?
-              if ex = existing_indexes.find { |e| i != e && e.equivalent?(i) }
-                i.with_name(ex.name)
+              if (existing = existing_indexes.find { |e| i != e && e.equivalent?(i) })
+                i.with_name(existing.name)
               end
             end || i
           end
@@ -514,15 +495,13 @@ module Generators
           end
           model_has_primary_key    = model_indexes.any?    { |i| i.name == ::DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME }
 
-          add_indexes_init = model_indexes - existing_indexes
-          drop_indexes_init = existing_indexes - model_indexes
           undo_add_indexes = []
-          undo_drop_indexes = []
-          add_indexes = add_indexes_init.map do |i|
+          add_indexes = (model_indexes - existing_indexes).map do |i|
             undo_add_indexes << drop_index(old_table_name, i.name) unless i.name == ::DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME
             i.to_add_statement(new_table_name, existing_has_primary_key)
           end
-          drop_indexes = drop_indexes_init.map do |i|
+          undo_drop_indexes = []
+          drop_indexes = (existing_indexes - model_indexes).map do |i|
             undo_drop_indexes << i.to_add_statement(old_table_name, model_has_primary_key)
             drop_index(new_table_name, i.name) unless i.name == ::DeclareSchema::Model::IndexDefinition::PRIMARY_KEY_NAME
           end.compact
@@ -538,51 +517,41 @@ module Generators
         end
 
         def change_foreign_key_constraints(model, old_table_name)
-          ActiveRecord::Base.connection.class.name.match?(/SQLite3Adapter/) and raise 'SQLite does not support foreign keys'
-          return [[], []] if Migrator.disable_indexing
+          ActiveRecord::Base.connection.class.name.match?(/SQLite3Adapter/) and raise ArgumentError, 'SQLite does not support foreign keys'
+          Migrator.disable_indexing and return [[], []]
 
           new_table_name = model.table_name
           existing_fks = ::DeclareSchema::Model::ForeignKeyDefinition.for_model(model, old_table_name)
           model_fks = model.constraint_specs
-          add_fks = model_fks - existing_fks
-          drop_fks = existing_fks - model_fks
-          undo_add_fks = []
-          undo_drop_fks = []
 
-          add_fks.map! do |fk|
+          undo_add_fks = []
+          add_fks = (model_fks - existing_fks).map do |fk|
             # next if fk.parent.constantize.abstract_class || fk.parent == fk.model.class_name
-            undo_add_fks << remove_foreign_key(old_table_name, fk.options[:constraint_name])
+            undo_add_fks << remove_foreign_key(old_table_name, fk.constraint_name)
             fk.to_add_statement
-          end.compact
+          end
 
-          drop_fks.map! do |fk|
+          undo_drop_fks = []
+          drop_fks = (existing_fks - model_fks).map do |fk|
             undo_drop_fks << fk.to_add_statement
-            remove_foreign_key(new_table_name, fk.options[:constraint_name])
+            remove_foreign_key(new_table_name, fk.constraint_name)
           end
 
           [drop_fks + add_fks, undo_add_fks + undo_drop_fks]
         end
 
         def remove_foreign_key(old_table_name, fk_name)
-          "remove_foreign_key('#{old_table_name}', name: '#{fk_name}')"
+          "remove_foreign_key(#{old_table_name.inspect}, name: #{fk_name.to_s.inspect})"
         end
 
-        def format_options(options, type, changing: false)
+        def format_options(options)
           options.map do |k, v|
-            if !changing && ((k == :limit && type == :decimal) || (k == :null && v == true))
-              next
-            end
-
-            if !::DeclareSchema::Model::FieldSpec.mysql_text_limits? && k == :limit && type == :text
-              next
-            end
-
             if k.is_a?(Symbol)
               "#{k}: #{v.inspect}"
             else
               "#{k.inspect} => #{v.inspect}"
             end
-          end.compact
+          end
         end
 
         def fk_field_options(model, field_name)
@@ -620,7 +589,33 @@ module Generators
           end
         end
 
-        # TODO: TECH-4814 remove all methods from here through end of file
+        def with_previous_model_table_name(model, table_name)
+          model_table_name, model.table_name = model.table_name, table_name
+          yield
+        ensure
+          model.table_name = model_table_name
+        end
+
+        def add_column_back(model, current_table_name, col_name)
+          with_previous_model_table_name(model, current_table_name) do
+            column = model.columns_hash[col_name] or raise "no columns_hash entry found for #{col_name} in #{model.inspect}"
+            col_spec = ::DeclareSchema::Model::Column.new(model, current_table_name, column)
+            schema_attributes = col_spec.schema_attributes
+            type = schema_attributes.delete(:type) or raise "no :type found in #{schema_attributes.inspect}"
+            ["add_column :#{current_table_name}, :#{col_name}, #{type.inspect}", *format_options(schema_attributes)].join(', ')
+          end
+        end
+
+        def change_column_back(model, current_table_name, col_name)
+          with_previous_model_table_name(model, current_table_name) do
+            column = model.columns_hash[col_name] or raise "no columns_hash entry found for #{col_name} in #{model.inspect}"
+            col_spec = ::DeclareSchema::Model::Column.new(model, current_table_name, column)
+            schema_attributes = col_spec.schema_attributes
+            type = schema_attributes.delete(:type) or raise "no :type found in #{schema_attributes.inspect}"
+            ["change_column #{current_table_name.to_sym.inspect}", col_name.to_sym.inspect, type.to_sym.inspect, *format_options(schema_attributes)].join(', ')
+          end
+        end
+
         def default_collation_from_charset(charset)
           case charset
           when "utf8"
@@ -630,64 +625,47 @@ module Generators
           end
         end
 
-        def revert_table(table)
-          res = StringIO.new
-          schema_dumper_klass = case Rails::VERSION::MAJOR
-                                when 4
-                                  ActiveRecord::SchemaDumper
-                                else
-                                  ActiveRecord::ConnectionAdapters::SchemaDumper
-                                end
-          schema_dumper_klass.send(:new, ActiveRecord::Base.connection).send(:table, table, res)
+        SchemaDumper = case Rails::VERSION::MAJOR
+                       when 4
+                         ActiveRecord::SchemaDumper
+                       else
+                         ActiveRecord::ConnectionAdapters::SchemaDumper
+                       end
+
+        def add_table_back(table)
+          dumped_schema_stream = StringIO.new
+          SchemaDumper.send(:new, ActiveRecord::Base.connection).send(:table, table, dumped_schema_stream)
 
-          result = res.string.strip.gsub("\n  ", "\n")
+          dumped_schema = dumped_schema_stream.string.strip.gsub!("\n  ", "\n")
           if connection.class.name.match?(/mysql/i)
-            if !result['options: ']
-              result = result.sub('",', "\", options: \"DEFAULT CHARSET=#{Generators::DeclareSchema::Migration::Migrator.default_charset} "+
-                                   "COLLATE=#{Generators::DeclareSchema::Migration::Migrator.default_collation}\",")
-            end
-            default_charset   = result[/CHARSET=(\w+)/, 1]   or raise "unable to find charset in #{result.inspect}"
-            default_collation = result[/COLLATE=(\w+)/, 1] || default_collation_from_charset(default_charset) or
-              raise "unable to find collation in #{result.inspect} or charset #{default_charset.inspect}"
-            result = result.split("\n").map do |line|
-              if line['t.text'] || line['t.string']
-                if !line['charset: ']
-                  if line['collation: ']
-                    line = line.sub('collation: ', "charset: #{default_charset.inspect}, collation: ")
-                  else
-                    line += ", charset: #{default_charset.inspect}"
-                  end
-                end
-                line['collation: '] or line += ", collation: #{default_collation.inspect}"
-              end
-              line
-            end.join("\n")
+            fix_mysql_charset_and_collation(dumped_schema)
+          else
+            dumped_schema
           end
-          result
         end
 
-        def column_options_from_reverted_table(table, column)
-          revert = revert_table(table)
-          if (md = revert.match(/\s*t\.column\s+"#{column}",\s+(:[a-zA-Z0-9_]+)(?:,\s+(.*?)$)?/m))
-            # Ugly migration
-            _, type, options = *md
-          elsif (md = revert.match(/\s*t\.([a-z_]+)\s+"#{column}"(?:,\s+(.*?)$)?/m))
-            # Sexy migration
-            _, string_type, options = *md
-            type = ":#{string_type}"
+        # TODO: rewrite this method to use charset and collation variables rather than manipulating strings. -Colin
+        def fix_mysql_charset_and_collation(dumped_schema)
+          if !dumped_schema['options: ']
+            dumped_schema.sub!('",', "\", options: \"DEFAULT CHARSET=#{Generators::DeclareSchema::Migration::Migrator.default_charset} "+
+              "COLLATE=#{Generators::DeclareSchema::Migration::Migrator.default_collation}\",")
           end
-          type or raise "unable to find column options for #{table}.#{column} in #{revert.inspect}"
-          [type, options]
-        end
-
-        def change_column_back(table, column)
-          type, options = column_options_from_reverted_table(table, column)
-          ["change_column :#{table}, :#{column}, #{type}", options&.strip].compact.join(', ')
-        end
-
-        def revert_column(table, column)
-          type, options = column_options_from_reverted_table(table, column)
-          ["add_column :#{table}, :#{column}, #{type}", options&.strip].compact.join(', ')
+          default_charset   = dumped_schema[/CHARSET=(\w+)/, 1]   or raise "unable to find charset in #{dumped_schema.inspect}"
+          default_collation = dumped_schema[/COLLATE=(\w+)/, 1] || default_collation_from_charset(default_charset) or
+            raise "unable to find collation in #{dumped_schema.inspect} or charset #{default_charset.inspect}"
+          dumped_schema.split("\n").map do |line|
+            if line['t.text'] || line['t.string']
+              if !line['charset: ']
+                if line['collation: ']
+                  line.sub!('collation: ', "charset: #{default_charset.inspect}, collation: ")
+                else
+                  line << ", charset: #{default_charset.inspect}"
+                end
+              end
+              line['collation: '] or line << ", collation: #{default_collation.inspect}"
+            end
+            line
+          end.join("\n")
         end
       end
     end