declare_schema 0.1.0

data/lib/declare_schema/model/field_spec.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+module DeclareSchema
+  module Model
+    class FieldSpec
+      class UnknownSqlTypeError < RuntimeError; end
+
+      MYSQL_TINYTEXT_LIMIT    = 0xff
+      MYSQL_TEXT_LIMIT        = 0xffff
+      MYSQL_MEDIUMTEXT_LIMIT  = 0xff_ffff
+      MYSQL_LONGTEXT_LIMIT    = 0xffff_ffff
+
+      MYSQL_TEXT_LIMITS_ASCENDING = [MYSQL_TINYTEXT_LIMIT, MYSQL_TEXT_LIMIT, MYSQL_MEDIUMTEXT_LIMIT, MYSQL_LONGTEXT_LIMIT].freeze
+
+      class << self
+        # method for easy stubbing in tests
+        def mysql_text_limits?
+          if defined?(@mysql_text_limits)
+            @mysql_text_limits
+          else
+            @mysql_text_limits = ActiveRecord::Base.connection.class.name.match?(/mysql/i)
+          end
+        end
+
+        def round_up_mysql_text_limit(limit)
+          MYSQL_TEXT_LIMITS_ASCENDING.find do |mysql_supported_text_limit|
+            if limit <= mysql_supported_text_limit
+              mysql_supported_text_limit
+            end
+          end or raise ArgumentError, "limit of #{limit} is too large for MySQL"
+        end
+      end
+
+      attr_reader :model, :name, :type, :position, :options
+
+      def initialize(model, name, type, options = {})
+        # Invoca change - searching for the primary key was causing an additional database read on every model load.  Assume
+        # "id" which works for invoca.
+        # raise ArgumentError, "you cannot provide a field spec for the primary key" if name == model.primary_key
+        name == "id" and raise ArgumentError, "you cannot provide a field spec for the primary key"
+
+        @model = model
+        @name = name.to_sym
+        @type = type.is_a?(String) ? type.to_sym : type
+        position_option = options.delete(:position)
+        @options = options
+
+        case type
+        when :text
+          @options[:default] and raise "default may not be given for :text field #{model}##{@name}"
+          if self.class.mysql_text_limits?
+            @options[:limit] = self.class.round_up_mysql_text_limit(@options[:limit] || MYSQL_LONGTEXT_LIMIT)
+          end
+        when :string
+          @options[:limit] or raise "limit must be given for :string field #{model}##{@name}: #{@options.inspect}; do you want 255?"
+        end
+        @position = position_option || model.field_specs.length
+      end
+
+      TYPE_SYNONYMS = { timestamp: :datetime }.freeze
+
+      SQLITE_COLUMN_CLASS =
+        begin
+          ActiveRecord::ConnectionAdapters::SQLiteColumn
+        rescue NameError
+          NilClass
+        end
+
+      def sql_type
+        @options[:sql_type] || begin
+                                if native_type?(type)
+                                  type
+                                else
+                                  field_class = DeclareSchema.to_class(type)
+                                  field_class && field_class::COLUMN_TYPE or raise UnknownSqlTypeError, "#{type.inspect} for #{model}.#{@name}"
+                                end
+                              end
+      end
+
+      def sql_options
+        @options.except(:ruby_default, :validates)
+      end
+
+      def limit
+        @options[:limit] || native_types[sql_type][:limit]
+      end
+
+      def precision
+        @options[:precision]
+      end
+
+      def scale
+        @options[:scale]
+      end
+
+      def null
+        !:null.in?(@options) || @options[:null]
+      end
+
+      def default
+        @options[:default]
+      end
+
+      def comment
+        @options[:comment]
+      end
+
+      def same_type?(col_spec)
+        type = sql_type
+        normalized_type           = TYPE_SYNONYMS[type] || type
+        normalized_col_spec_type  = TYPE_SYNONYMS[col_spec.type] || col_spec.type
+        normalized_type == normalized_col_spec_type
+      end
+
+      def different_to?(col_spec)
+        !same_type?(col_spec) ||
+          # we should be able to use col_spec.comment, but col_spec has
+          # a nil table_name for some strange reason.
+          (model.table_exists? &&
+            ActiveRecord::Base.respond_to?(:column_comment) &&
+            !(col_comment = ActiveRecord::Base.column_comment(col_spec.name, model.table_name)).nil? &&
+            col_comment != comment
+          ) ||
+          begin
+            native_type = native_types[type]
+            check_attributes = [:null, :default]
+            check_attributes += [:precision, :scale] if sql_type == :decimal && !col_spec.is_a?(SQLITE_COLUMN_CLASS)  # remove when rails fixes https://rails.lighthouseapp.com/projects/8994-ruby-on-rails/tickets/2872
+            check_attributes -= [:default] if sql_type == :text && col_spec.class.name =~ /mysql/i
+            check_attributes << :limit if sql_type.in?([:string, :binary, :varbinary, :integer, :enum]) ||
+                                          (sql_type == :text && self.class.mysql_text_limits?)
+            check_attributes.any? do |k|
+              if k == :default
+                case Rails::VERSION::MAJOR
+                when 4
+                  col_spec.type_cast_from_database(col_spec.default) != col_spec.type_cast_from_database(default)
+                else
+                  cast_type = ActiveRecord::Base.connection.lookup_cast_type_from_column(col_spec) or raise "cast_type not found for #{col_spec.inspect}"
+                  cast_type.deserialize(col_spec.default) != cast_type.deserialize(default)
+                end
+              else
+                col_value = col_spec.send(k)
+                if col_value.nil? && native_type
+                  col_value = native_type[k]
+                end
+                col_value != send(k)
+              end
+            end
+          end
+      end
+
+      private
+
+      def native_type?(type)
+        type.to_sym != :primary_key && native_types.has_key?(type)
+      end
+
+      def native_types
+        Generators::DeclareSchema::Migration::Migrator.native_types
+      end
+    end
+  end
+end

data/lib/declare_schema/model/index_spec.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+module DeclareSchema
+  module Model
+    class IndexSpec
+      include Comparable
+
+      attr_reader :table, :fields, :explicit_name, :name, :unique, :where
+
+      class IndexNameTooLongError < RuntimeError; end
+
+      PRIMARY_KEY_NAME = "PRIMARY_KEY"
+      MYSQL_INDEX_NAME_MAX_LENGTH = 64
+
+      def initialize(model, fields, options = {})
+        @model = model
+        @table = options.delete(:table_name) || model.table_name
+        @fields = Array.wrap(fields).map(&:to_s)
+        @explicit_name = options[:name] unless options.delete(:allow_equivalent)
+        @name = options.delete(:name) || model.connection.index_name(table, column: @fields).gsub(/index.*_on_/, 'on_')
+        @unique = options.delete(:unique) || name == PRIMARY_KEY_NAME || false
+
+        if @name.length > MYSQL_INDEX_NAME_MAX_LENGTH
+          raise IndexNameTooLongError, "Index '#{@name}' exceeds MySQL limit of #{MYSQL_INDEX_NAME_MAX_LENGTH} characters. Give it a shorter name."
+        end
+
+        if (where = options[:where])
+          @where = where.start_with?('(') ? where : "(#{where})"
+        end
+      end
+
+      class << self
+        # extract IndexSpecs from an existing table
+        def for_model(model, old_table_name = nil)
+          t = old_table_name || model.table_name
+          connection = model.connection.dup
+          # TODO: Change below to use prepend
+          class << connection              # defeat Rails code that skips the primary keys by changing their name to PRIMARY_KEY_NAME
+            def each_hash(result)
+              super do |hash|
+                if hash[:Key_name] == "PRIMARY"
+                  hash[:Key_name] = PRIMARY_KEY_NAME
+                end
+                yield hash
+              end
+            end
+          end
+          connection.indexes(t).map do |i|
+            new(model, i.columns, name: i.name, unique: i.unique, where: i.where, table_name: old_table_name) unless model.ignore_indexes.include?(i.name)
+          end.compact
+        end
+      end
+
+      def primary_key?
+        name == PRIMARY_KEY_NAME
+      end
+
+      def to_add_statement(new_table_name, existing_primary_key = nil)
+        if primary_key? && !ActiveRecord::Base.connection.class.name.match?(/SQLite3Adapter/)
+          to_add_primary_key_statement(new_table_name, existing_primary_key)
+        else
+          r = +"add_index #{new_table_name.to_sym.inspect}, #{fields.map(&:to_sym).inspect}"
+          r += ", unique: true"      if unique
+          r += ", where: '#{where}'" if where.present?
+          r += ", name: '#{name}'"
+          r
+        end
+      end
+
+      def to_add_primary_key_statement(new_table_name, existing_primary_key)
+        drop = "DROP PRIMARY KEY, " if existing_primary_key
+        statement = "ALTER TABLE #{new_table_name} #{drop}ADD PRIMARY KEY (#{fields.join(', ')})"
+        "execute #{statement.inspect}"
+      end
+
+      def to_key
+        @key ||= [table, fields, name, unique, where].map(&:to_s)
+      end
+
+      def settings
+        @settings ||= [table, fields, unique].map(&:to_s)
+      end
+
+      def hash
+        to_key.hash
+      end
+
+      def <=>(rhs)
+        to_key <=> rhs.to_key
+      end
+
+      def equivalent?(rhs)
+        settings == rhs.settings
+      end
+
+      def with_name(new_name)
+        self.class.new(@model, @fields, table_name: @table_name, index_name: @index_name, unique: @unique, name: new_name)
+      end
+
+      alias eql? ==
+    end
+
+    class ForeignKeySpec
+      include Comparable
+
+      attr_reader :constraint_name, :model, :foreign_key, :options, :on_delete_cascade
+
+      def initialize(model, foreign_key, options = {})
+        @model = model
+        @foreign_key = foreign_key.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
+
+        # Empty constraint lets mysql generate the name
+      end
+
+      class << self
+        def for_model(model, old_table_name)
+          show_create_table = model.connection.select_rows("show create table #{model.connection.quote_table_name(old_table_name)}").first.last
+          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[:dependent] = :delete if fkc['ON DELETE CASCADE']
+
+            new(model, foreign_key, options)
+          end
+        end
+      end
+
+      def parent_table_name
+        @parent_table_name ||=
+          options[:class_name]&.is_a?(Class) &&
+          options[:class_name].respond_to?(:table_name) &&
+          options[:class_name]&.table_name
+        @parent_table_name ||=
+          options[:class_name]&.constantize &&
+          options[:class_name].constantize.respond_to?(:table_name) &&
+          options[:class_name].constantize.table_name ||
+          foreign_key.gsub(/_id/, '').camelize.constantize.table_name
+      end
+
+      attr_writer :parent_table_name
+
+      def to_add_statement(_ = true)
+        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}"
+      end
+
+      def to_key
+        @key ||= [@child_table, parent_table_name, @foreign_key_name, @on_delete_cascade].map(&:to_s)
+      end
+
+      def hash
+        to_key.hash
+      end
+
+      def <=>(rhs)
+        to_key <=> rhs.to_key
+      end
+
+      alias eql? ==
+    end
+  end
+end

data/lib/declare_schema/railtie.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'declare_schema'
+require 'rails'
+
+module DeclareSchema
+  class Railtie < Rails::Railtie
+    ActiveSupport.on_load(:active_record) do
+      require 'declare_schema/extensions/active_record/fields_declaration'
+    end
+  end
+end

data/lib/declare_schema/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module DeclareSchema
+  VERSION = "0.1.0"
+end

data/lib/generators/declare_schema/migration/USAGE

@@ -0,0 +1,47 @@
+Description:
+
+        This generator compares your existing schema against the
+        schema declared inside your fields declarations in your
+        models.
+
+        If the generator finds differences, it will display the
+        migration it has created, and ask you if you wish to
+        [g]enerate migration, generate and [m]igrate now or [c]ancel?
+        Enter "g" to just generate the migration but do not run it.
+        Enter "m" to generate the migration and run it, or press "c"
+        to do nothing.
+
+        The generator will then prompt you for the migration name,
+        supplying a numbered default name.
+
+        The generator is conservative and will prompt you to resolve
+        any ambiguities.
+
+Examples:
+
+        $ rails generate declare_schema:migration
+
+        ---------- Up Migration ----------
+        create_table :foos do |t|
+          t.datetime :created_at
+          t.datetime :updated_at
+        end
+        ----------------------------------
+
+        ---------- Down Migration --------
+        drop_table :foos
+        ----------------------------------
+        What now: [g]enerate migration, generate and [m]igrate now or [c]ancel? m
+
+        Migration filename:
+        (you can type spaces instead of '_' -- every little helps)
+        Filename [declare_schema_migration_2]: create_foo
+              exists  db/migrate
+              create  db/migrate/20091023183838_create_foo.rb
+        (in /work/foo)
+        ==  CreateFoo: migrating ======================================================
+        -- create_table(:yos)
+           -> 0.0856s
+        ==  CreateFoo: migrated (0.0858s) =============================================
+
+

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

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require 'rails/generators/migration'
+require 'rails/generators/active_record'
+require 'generators/declare_schema/support/thor_shell'
+
+module DeclareSchema
+  class MigrationGenerator < Rails::Generators::Base
+    source_root File.expand_path('templates', __dir__)
+
+    argument :name, type: :string, optional: true
+
+    include Rails::Generators::Migration
+    include DeclareSchema::Support::ThorShell
+
+    class << self
+      # the Rails::Generators::Migration.next_migration_number gives a NotImplementedError
+      # in Rails 3.0.0.beta4, so we need to implement the logic of ActiveRecord.
+      # For other ORMs we will wait for the rails implementation
+      # see http://groups.google.com/group/rubyonrails-talk/browse_thread/thread/a507ce419076cda2
+      def next_migration_number(dirname)
+        ActiveRecord::Generators::Base.next_migration_number(dirname)
+      end
+
+      def banner
+        "rails generate declare_schema:migration #{arguments.map(&:usage).join(' ')} [options]"
+      end
+    end
+
+    class_option :drop,
+                 aliases: '-d',
+                 type: :boolean,
+                 desc: "Don't prompt with 'drop or rename' - just drop everything"
+
+    class_option :default_name,
+                 aliases: '-n',
+                 type: :boolean,
+                 desc: "Don't prompt for a migration name - just pick one"
+
+    class_option :generate,
+                 aliases: '-g',
+                 type: :boolean,
+                 desc: "Don't prompt for action - generate the migration"
+
+    class_option :migrate,
+                 aliases: '-m',
+                 type: :boolean,
+                 desc: "Don't prompt for action - generate and migrate"
+
+    def migrate
+      return if migrations_pending?
+
+      generator = Generators::DeclareSchema::Migration::Migrator.new(->(c, d, k, p) { extract_renames!(c, d, k, p) })
+      up, down = generator.generate
+
+      if up.blank?
+        say "Database and models match -- nothing to change"
+        return
+      end
+
+      say "\n---------- Up Migration ----------"
+      say up
+      say "----------------------------------"
+
+      say "\n---------- Down Migration --------"
+      say down
+      say "----------------------------------"
+
+      action = options[:generate] && 'g' ||
+               options[:migrate] && 'm' ||
+               choose("\nWhat now: [g]enerate migration, generate and [m]igrate now or [c]ancel?", /^(g|m|c)$/)
+
+      if action != 'c'
+        if name.blank? && !options[:default_name]
+          final_migration_name = choose("\nMigration filename: [<enter>=#{migration_name}|<custom_name>]:", /^[a-z0-9_ ]*$/, migration_name).strip.gsub(' ', '_')
+        end
+        final_migration_name = migration_name if final_migration_name.blank?
+
+        up.gsub!("\n", "\n    ")
+        up.gsub!(/ +\n/, "\n")
+        down.gsub!("\n", "\n    ")
+        down.gsub!(/ +\n/, "\n")
+
+        @up = up
+        @down = down
+        @migration_class_name = final_migration_name.camelize
+
+        migration_template 'migration.rb.erb', "db/migrate/#{final_migration_name.underscore}.rb"
+        if action == 'm'
+          case Rails::VERSION::MAJOR
+          when 4
+            rake('db:migrate')
+          else
+            rails_command('db:migrate')
+          end
+        end
+      end
+    rescue ::DeclareSchema::Model::FieldSpec::UnknownSqlTypeError => ex
+      say "Invalid field type: #{ex}"
+    end
+
+    private
+
+    def migrations_pending?
+      migrations = case Rails::VERSION::MAJOR
+                   when 4
+                     ActiveRecord::Migrator.migrations('db/migrate')
+                   when 5
+                     ActiveRecord::MigrationContext.new(ActiveRecord::Migrator.migrations_paths).migrations
+                   else
+                     ActiveRecord::MigrationContext.new(ActiveRecord::Migrator.migrations_paths, ActiveRecord::SchemaMigration).migrations
+                   end
+      pending_migrations = case Rails::VERSION::MAJOR
+                           when 4, 5
+                             ActiveRecord::Migrator.new(:up, migrations).pending_migrations
+                           else
+                             ActiveRecord::Migrator.new(:up, migrations, ActiveRecord::SchemaMigration).pending_migrations
+                           end
+
+      if pending_migrations.any?
+        say "You have #{pending_migrations.size} pending migration#{'s' if pending_migrations.size > 1}:"
+        pending_migrations.each do |pending_migration|
+          say format('  %4d %s', pending_migration.version, pending_migration.name)
+        end
+        true
+      else
+        false
+      end
+    end
+
+    def extract_renames!(to_create, to_drop, kind_str, name_prefix = "")
+      to_rename = {}
+
+      unless options[:drop]
+
+        rename_to_choices = to_create
+        to_drop.dup.each do |t|
+          loop do
+            if rename_to_choices.empty?
+              say "\nCONFIRM DROP! #{kind_str} #{name_prefix}#{t}"
+              resp = ask("Enter 'drop #{t}' to confirm or press enter to keep:")
+              if resp.strip == "drop #{t}"
+                break
+              elsif resp.strip.empty?
+                to_drop.delete(t)
+                break
+              else
+                next
+              end
+            else
+              say "\nDROP, RENAME or KEEP?: #{kind_str} #{name_prefix}#{t}"
+              say "Rename choices: #{to_create * ', '}"
+              resp = ask "Enter either 'drop #{t}' or one of the rename choices or press enter to keep:"
+              resp = resp.strip
+
+              if resp == "drop #{t}"
+                # Leave things as they are
+                break
+              else
+                resp.gsub!(' ', '_')
+                to_drop.delete(t)
+                if resp.in?(rename_to_choices)
+                  to_rename[t] = resp
+                  to_create.delete(resp)
+                  rename_to_choices.delete(resp)
+                  break
+                elsif resp.empty?
+                  break
+                else
+                  next
+                end
+              end
+            end
+          end
+        end
+      end
+      to_rename
+    end
+
+    def migration_name
+      name || Generators::DeclareSchema::Migration::Migrator.default_migration_name
+    end
+  end
+end