migration_comments 0.2.1 → 0.3.0

data/README.rdoc

@@ -4,8 +4,9 @@ Comments for your migrations
 
 Tested on:
 
-* Ruby 1.8.7/1.9.x using Rails 3.x
-* Ruby 1.8.6/1.8.7 using Rails 2.3.x.
+Rails 4.x:: using Ruby 1.9.3 / 2.0
+Rails 3.x:: using Ruby 1.8.7 / 1.9.x / 2.0
+Rails 2.3.x (deprecated):: using 1.8.6 / 1.8.7
 
 == Why?
 

data/Rakefile

@@ -1 +1,8 @@
 require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/*_test.rb']
+  t.verbose = true
+end

data/lib/migration_comments.rb

@@ -1,4 +1,5 @@
 require "migration_comments/version"
+require "migration_comments/schema_formatter"
 
 require 'migration_comments/active_record/schema_dumper'
 require 'migration_comments/active_record/connection_adapters/comment_definition'
@@ -6,16 +7,24 @@ require 'migration_comments/active_record/connection_adapters/column_definition'
 require 'migration_comments/active_record/connection_adapters/column'
 require 'migration_comments/active_record/connection_adapters/table'
 require 'migration_comments/active_record/connection_adapters/table_definition'
+require 'migration_comments/active_record/connection_adapters/alter_table'
 require 'migration_comments/active_record/connection_adapters/abstract_adapter'
+require 'migration_comments/active_record/connection_adapters/abstract_adapter/schema_creation'
 require 'migration_comments/active_record/connection_adapters/mysql_adapter'
 require 'migration_comments/active_record/connection_adapters/mysql2_adapter'
 require 'migration_comments/active_record/connection_adapters/postgresql_adapter'
+require 'migration_comments/active_record/connection_adapters/abstract_sqlite_adapter'
 require 'migration_comments/active_record/connection_adapters/sqlite_adapter'
+require 'migration_comments/active_record/connection_adapters/sqlite3_adapter'
 
 require 'active_record/connection_adapters/abstract_adapter'
 
 module MigrationComments
   def self.setup
+    if ::ActiveRecord::VERSION::MAJOR == 2
+      warn "[DEPRECATION] MigrationComments support for ActiveRecord v2.3 is deprecated and will be removed in a future version."
+    end
+
     base_names = %w(SchemaDumper) +
       %w(ColumnDefinition Column Table TableDefinition AbstractAdapter).map{|name| "ConnectionAdapters::#{name}"}
 
@@ -27,10 +36,27 @@ module MigrationComments
       end
     end
 
-    %w(PostgreSQL Mysql Mysql2 SQLite).each do |adapter|
+    # Rails 4 introduces some new models that were not previously present
+    optimistic_models = []
+    optimistic_models << "ActiveRecord::ConnectionAdapters::AbstractAdapter::SchemaCreation"
+    optimistic_models << "ActiveRecord::ConnectionAdapters::AlterTable"
+    optimistic_models.each do |model_name|
+      begin
+        model = model_name.constantize
+        mc_class = "MigrationComments::#{model_name}".constantize
+        model.module_eval do
+          model.send(:include, mc_class)
+        end
+      rescue Exception => ex
+      end
+    end
+
+    adapters = %w(PostgreSQL Mysql Mysql2)
+    adapters << (::ActiveRecord::VERSION::MAJOR <= 3 ? "SQLite" : "SQLite3")
+    adapters.each do |adapter|
       begin
         require("active_record/connection_adapters/#{adapter.downcase}_adapter")
-        adapter_class = ('ActiveRecord::ConnectionAdapters::' << "#{adapter}Adapter").constantize
+        adapter_class = ('::ActiveRecord::ConnectionAdapters::' << "#{adapter}Adapter").constantize
         mc_class = ('MigrationComments::ActiveRecord::ConnectionAdapters::' << "#{adapter}Adapter").constantize
         adapter_class.module_eval do
           adapter_class.__send__(:include, mc_class)

data/lib/migration_comments/active_record/connection_adapters/abstract_adapter.rb

@@ -19,6 +19,10 @@ module MigrationComments::ActiveRecord::ConnectionAdapters
       false
     end
 
+    def inline_comments?
+      false
+    end
+
     # Remove a comment on a table (if set)
     def remove_table_comment(table_name)
       set_table_comment(table_name, nil)

data/lib/migration_comments/active_record/connection_adapters/abstract_adapter/schema_creation.rb

@@ -0,0 +1,40 @@
+module MigrationComments::ActiveRecord::ConnectionAdapters::AbstractAdapter
+  module SchemaCreation
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :column_options, :migration_comments
+        alias_method_chain :visit_TableDefinition, :migration_comments
+        alias_method_chain :visit_ColumnDefinition, :migration_comments
+      end
+    end
+
+    def column_options_with_migration_comments(o)
+      column_options = o.primary_key? ? {} : column_options_without_migration_comments(o)
+      column_options[:comment] = o.comment.comment_text if o.comment
+      column_options
+    end
+
+    def visit_TableDefinition_with_migration_comments(o)
+      if @conn.inline_comments?
+        create_sql = "CREATE#{' TEMPORARY' if o.temporary} TABLE "
+        create_sql << "#{quote_table_name(o.name)}#{o.table_comment} ("
+        create_sql << o.columns.map { |c| accept c }.join(', ')
+        create_sql << ") #{o.options}"
+        create_sql
+      else
+        visit_TableDefinition_without_migration_comments(o)
+      end
+    end
+
+    def visit_ColumnDefinition_with_migration_comments(o)
+      if @conn.inline_comments?
+        sql_type = type_to_sql(o.type.to_sym, o.limit, o.precision, o.scale)
+        column_sql = "#{quote_column_name(o.name)} #{sql_type}"
+        add_column_options!(column_sql, column_options(o))
+        column_sql
+      else
+        visit_ColumnDefinition_without_migration_comments(o)
+      end
+    end
+  end
+end

data/lib/migration_comments/active_record/connection_adapters/abstract_sqlite_adapter.rb

@@ -0,0 +1,85 @@
+module MigrationComments::ActiveRecord::ConnectionAdapters
+  module AbstractSQLiteAdapter
+    def comments_supported?
+      true
+    end
+
+    def inline_comments?
+      true
+    end
+
+    def set_table_comment(table_name, comment_text)
+      alter_table(table_name, :comment => comment_text)
+    end
+
+    def set_column_comment(table_name, column_name, comment_text)
+      sql_type = primary_key(table_name) == column_name.to_s ?
+          :primary_key :
+          column_for(table_name, column_name).sql_type
+      change_column table_name, column_name, sql_type, :comment => comment_text
+    end
+
+    def retrieve_table_comment(table_name)
+      result = select_rows(lookup_comment_sql(table_name))
+      if result[0][0] =~ /CREATE (?:TEMPORARY )?TABLE #{quote_table_name table_name} [^\(]*\/\*(.*)\*\/ \(/
+        $1
+      end
+    end
+
+    def retrieve_column_comments(table_name, *column_names)
+      if column_names.empty?
+        return columns(table_name).inject({}) { |m, v| m[v.name.to_sym] = v.comment if v.comment.present?; m }
+      end
+      result = select_rows(lookup_comment_sql(table_name))
+      result[0][0] =~ /^CREATE (?:TEMPORARY )?TABLE "\w*" [^\(]*(?:\/\*.*\*\/ )?\((.*)\)[^\)]*$/
+      col_defs = $1
+      comment_matches = col_defs.scan(/"([^",]+)"[^,]*\/\*(.+?)\*\//)
+      comment_matches.inject({}){|m, row| m[row.first.to_sym] = row.last; m}
+    end
+
+    def change_column_with_migration_comments(table_name, column_name, type, options = {}) #:nodoc:
+      adapter = self
+      alter_table(table_name) do |definition|
+        include_default = options_include_default?(options)
+        definition[column_name].instance_eval do
+          self.type    = type
+          self.limit   = options[:limit] if options.include?(:limit)
+          self.default = options[:default] if include_default
+          self.null    = options[:null] if options.include?(:null)
+          self.precision = options[:precision] if options.include?(:precision)
+          self.scale   = options[:scale] if options.include?(:scale)
+          self.comment = CommentDefinition.new(adapter, table_name, column_name, options[:comment]) if options.include?(:comment)
+        end
+      end
+    end
+
+    def column_for(table_name, column_name)
+      columns(table_name).detect{|col| col.name == column_name.to_s}
+    end
+
+    def comment_sql(comment_definition)
+      if comment_definition.nil? || comment_definition.comment_text.blank?
+        ""
+      else
+        " /*#{escaped_comment(comment_definition.comment_text)}*/"
+      end
+
+    end
+
+    def add_column_options!(sql, options)
+      super(sql, options)
+      if options.keys.include?(:comment)
+        sql << CommentDefinition.new(self, nil, nil, options[:comment]).to_sql
+      end
+    end
+
+    private
+    def escaped_comment(comment)
+      comment.gsub(/\*\//, "*-/")
+    end
+
+    def lookup_comment_sql(table_name)
+      "select sql from (select * from sqlite_master where type='table' union select * from sqlite_temp_master where type='table') where tbl_name = '#{table_name}'"
+    end
+  end
+end

data/lib/migration_comments/active_record/connection_adapters/alter_table.rb

@@ -0,0 +1,17 @@
+module MigrationComments::ActiveRecord::ConnectionAdapters
+  module AlterTable
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :add_column, :migration_comments
+      end
+    end
+
+    def add_column_with_migration_comments(name, type, options)
+      add_column_without_migration_comments(name, type, options)
+      if options.keys.include?(:comment)
+        column = @adds.last
+        column.comment = CommentDefinition.new(nil, @td, name, options[:comment])
+      end
+    end
+  end
+end

data/lib/migration_comments/active_record/connection_adapters/mysql_adapter.rb

@@ -2,12 +2,15 @@ module MigrationComments::ActiveRecord::ConnectionAdapters
   module MysqlAdapter
     def self.included(base)
       base.class_eval do
-        attr_accessor :database_name
         alias_method_chain :create_table, :migration_comments
         alias_method_chain :change_column, :migration_comments
       end
     end
 
+    def comments_supported?
+      true
+    end
+
     def set_table_comment(table_name, comment_text)
       execute "ALTER TABLE #{quote_table_name table_name} COMMENT #{escaped_comment(comment_text)}"
     end
@@ -31,14 +34,14 @@ module MigrationComments::ActiveRecord::ConnectionAdapters
     def retrieve_column_comments(table_name, *column_names)
       result = select_rows(column_comment_sql(table_name, *column_names))
       return {} if result.nil?
-      found = result.inject({}){|m, row| m[row[0].to_sym] = (row[1].blank? ? nil : row[1]); m}
-
+      result.inject({}){|m, row| m[row[0].to_sym] = (row[1].blank? ? nil : row[1]); m}
     end
 
     def create_table_with_migration_comments(table_name, options={}, &block)
       local_table_definition = nil
       create_table_without_migration_comments(table_name, options) do |td|
         local_table_definition = td
+        local_table_definition.base = self
         local_table_definition.comment options[:comment] if options.has_key?(:comment)
         block.call(td)
       end
@@ -76,7 +79,6 @@ module MigrationComments::ActiveRecord::ConnectionAdapters
     end
 
     def table_comment_sql(table_name)
-      ensure_database_name
       <<SQL
 SELECT table_comment FROM INFORMATION_SCHEMA.TABLES
   WHERE table_schema = '#{database_name}'
@@ -85,7 +87,6 @@ SQL
     end
 
     def column_comment_sql(table_name, *column_names)
-      ensure_database_name
       col_matcher_sql = column_names.empty? ? "" : " AND column_name IN (#{column_names.map{|c_name| "'#{c_name}'"}.join(',')})"
       <<SQL
 SELECT column_name, column_comment FROM INFORMATION_SCHEMA.COLUMNS
@@ -94,10 +95,8 @@ SELECT column_name, column_comment FROM INFORMATION_SCHEMA.COLUMNS
 SQL
     end
 
-    def ensure_database_name
-      return if database_name
-      info = YAML::load(IO.read('config/database.yml'))
-      @database_name = info[ENV['DB'] || Rails.env.to_s]["database"]
+    def database_name
+      @database_name ||= select_rows("SELECT DATABASE()")[0][0]
     end
 
   end

data/lib/migration_comments/active_record/connection_adapters/postgresql_adapter.rb

@@ -37,6 +37,7 @@ module MigrationComments::ActiveRecord::ConnectionAdapters
       local_table_definition = nil
       create_table_without_migration_comments(table_name, options) do |td|
         local_table_definition = td
+        local_table_definition.base = self
         local_table_definition.comment options[:comment] if options.has_key?(:comment)
         block.call(td)
       end

data/lib/migration_comments/active_record/connection_adapters/sqlite3_adapter.rb

@@ -0,0 +1,75 @@
+module MigrationComments::ActiveRecord::ConnectionAdapters
+  module SQLite3Adapter
+    include AbstractSQLiteAdapter
+
+    def self.included(base)
+      base.class_eval do
+        alias_method_chain :columns, :migration_comments
+        alias_method_chain :copy_table, :migration_comments
+        alias_method_chain :change_column, :migration_comments
+      end
+    end
+
+    def create_table(table_name, options = {})
+      td = create_table_definition table_name, options[:temporary], options[:options]
+      td.base = self
+
+      unless options[:id] == false
+        pk = options.fetch(:primary_key) {
+          ActiveRecord::Base.get_primary_key table_name.to_s.singularize
+        }
+
+        td.primary_key pk, options.fetch(:id, :primary_key), options
+      end
+      td.comment options[:comment] if options.has_key?(:comment)
+
+      yield td if block_given?
+
+      if options[:force] && table_exists?(table_name)
+        drop_table(table_name, options)
+      end
+
+      execute schema_creation.accept td
+      td.indexes.each_pair { |c,o| add_index table_name, c, o }
+    end
+
+    def columns_with_migration_comments(table_name)
+      cols = columns_without_migration_comments(table_name)
+      comments = retrieve_column_comments(table_name, *(cols.map(&:name)))
+      cols.each do |col|
+        col.comment = comments[col.name.to_sym] if comments.has_key?(col.name.to_sym)
+      end
+      cols
+    end
+
+    def copy_table_with_migration_comments(from, to, options = {}) #:nodoc:
+      from_primary_key = primary_key(from)
+      options[:id] = false
+      unless options.has_key?(:comment)
+        table_comment = retrieve_table_comment(from)
+        options = options.merge(:comment => table_comment) if table_comment
+      end
+      create_table(to, options) do |definition|
+        @definition = definition
+        @definition.primary_key(from_primary_key) if from_primary_key.present?
+        columns(from).each do |column|
+          column_name = options[:rename] ?
+              (options[:rename][column.name] ||
+                  options[:rename][column.name.to_sym] ||
+                  column.name) : column.name
+          next if column_name == from_primary_key
+
+          @definition.column(column_name, column.type,
+                             :limit => column.limit, :default => column.default,
+                             :precision => column.precision, :scale => column.scale,
+                             :null => column.null, :comment => column.comment)
+        end
+        yield @definition if block_given?
+      end
+      copy_table_indexes(from, to, options[:rename] || {})
+      copy_table_contents(from, to,
+                          @definition.columns.map {|column| column.name},
+                          options[:rename] || {})
+    end
+  end
+end

data/lib/migration_comments/active_record/connection_adapters/sqlite_adapter.rb

@@ -1,46 +1,20 @@
 module MigrationComments::ActiveRecord::ConnectionAdapters
   module SQLiteAdapter
+    include AbstractSQLiteAdapter
+
     def self.included(base)
-      base.class_eval do
+      base.module_eval do
         alias_method_chain :columns, :migration_comments
         alias_method_chain :copy_table, :migration_comments
         alias_method_chain :change_column, :migration_comments
       end
     end
 
-    def set_table_comment(table_name, comment_text)
-      alter_table(table_name, :comment => comment_text)
-    end
-
-    def set_column_comment(table_name, column_name, comment_text)
-      sql_type = primary_key(table_name) == column_name.to_s ?
-          :primary_key :
-          column_for(table_name, column_name).sql_type
-      change_column table_name, column_name, sql_type, :comment => comment_text
-    end
-
-    def retrieve_table_comment(table_name)
-      result = select_rows(lookup_comment_sql(table_name))
-      if result[0][0] =~ /CREATE (?:TEMPORARY )?TABLE #{quote_table_name table_name} [^\(]*\/\*(.*)\*\/ \(/
-        $1
-      end
-    end
-
-    def retrieve_column_comments(table_name, *column_names)
-      if column_names.empty?
-        return columns(table_name).inject({}) { |m, v| m[v.name.to_sym] = v.comment if v.comment.present?; m }
-      end
-      result = select_rows(lookup_comment_sql(table_name))
-      result[0][0] =~ /^CREATE (?:TEMPORARY )?TABLE "\w*" [^\(]*(?:\/\*.*\*\/ )?\((.*)\)[^\)]*$/
-      col_defs = $1
-      comment_matches = col_defs.scan(/"([^",]+)"[^,]*\/\*(.+?)\*\//)
-      comment_matches.inject({}){|m, row| m[row.first.to_sym] = row.last; m}
-    end
-
     def create_table(table_name, options = {})
-      td = table_definition
+      td = ActiveRecord::ConnectionAdapters::TableDefinition.new(self)
       td.primary_key(options[:primary_key] || ActiveRecord::Base.get_primary_key(table_name.to_s.singularize)) unless options[:id] == false
       td.comment options[:comment] if options.has_key?(:comment)
+      td.base = self
 
       yield td if block_given?
 
@@ -57,22 +31,6 @@ module MigrationComments::ActiveRecord::ConnectionAdapters
       execute create_sql
     end
 
-    def change_column_with_migration_comments(table_name, column_name, type, options = {}) #:nodoc:
-      adapter = self
-      alter_table(table_name) do |definition|
-        include_default = options_include_default?(options)
-        definition[column_name].instance_eval do
-          self.type    = type
-          self.limit   = options[:limit] if options.include?(:limit)
-          self.default = options[:default] if include_default
-          self.null    = options[:null] if options.include?(:null)
-          self.precision = options[:precision] if options.include?(:precision)
-          self.scale   = options[:scale] if options.include?(:scale)
-          self.comment = CommentDefinition.new(adapter, table_name, column_name, options[:comment]) if options.include?(:comment)
-        end
-      end
-    end
-
     def columns_with_migration_comments(table_name, name = nil)
       cols = columns_without_migration_comments(table_name, name)
       comments = retrieve_column_comments(table_name, *(cols.map(&:name)))
@@ -82,19 +40,6 @@ module MigrationComments::ActiveRecord::ConnectionAdapters
       cols
     end
 
-    def column_for(table_name, column_name)
-      columns(table_name).detect{|col| col.name == column_name.to_s}
-    end
-
-    def comment_sql(comment_definition)
-      if comment_definition.nil? || comment_definition.comment_text.blank?
-        ""
-      else
-        " /*#{escaped_comment(comment_definition.comment_text)}*/"
-      end
-
-    end
-
     def copy_table_with_migration_comments(from, to, options = {}) #:nodoc:
       options = options.merge(:id => (!columns(from).detect{|c| c.name == 'id'}.nil? && 'id' == primary_key(from).to_s))
       unless options.has_key?(:comment)
@@ -122,21 +67,5 @@ module MigrationComments::ActiveRecord::ConnectionAdapters
         @definition.columns.map {|column| column.name},
         options[:rename] || {})
     end
-
-    def add_column_options!(sql, options)
-      super(sql, options)
-      if options.keys.include?(:comment)
-        sql << CommentDefinition.new(self, nil, nil, options[:comment]).to_sql
-      end
-    end
-
-    private
-    def escaped_comment(comment)
-      comment.gsub(/\*\//, "*-/")
-    end
-
-    def lookup_comment_sql(table_name)
-      "select sql from (select * from sqlite_master where type='table' union select * from sqlite_temp_master where type='table') where tbl_name = '#{table_name}'"
-    end
   end
 end

data/lib/migration_comments/active_record/connection_adapters/table_definition.rb

@@ -5,11 +5,12 @@ module MigrationComments::ActiveRecord::ConnectionAdapters
     def self.included(base)
       base.class_eval do
         alias_method_chain :column, :migration_comments
+        attr_accessor :base
       end
     end
 
     def comment(text)
-      @table_comment = CommentDefinition.new(@base, nil, nil, text)
+      @table_comment = CommentDefinition.new(base, nil, nil, text)
       self
     end
 
@@ -17,16 +18,16 @@ module MigrationComments::ActiveRecord::ConnectionAdapters
       column_without_migration_comments(name, type, options)
       if options.has_key?(:comment)
         col = self[name]
-        col.comment = CommentDefinition.new(@base, nil, name, options[:comment])
+        col.comment = CommentDefinition.new(base, nil, name, options[:comment])
       end
       self
     end
 
     def collect_comments(table_name)
       comments = []
-      comments << @table_comment << @columns.map(&:comment)
+      comments << @table_comment << columns.map(&:comment)
       comments.flatten!.compact!
-      comments.each{|comment| comment.table = table_name}
+      comments.each{|comment| comment.table = table_name; comment.adapter = base}
     end
   end
 end

data/lib/migration_comments/active_record/schema_dumper.rb

@@ -1,5 +1,6 @@
 module MigrationComments::ActiveRecord
   module SchemaDumper
+    include MigrationComments::SchemaFormatter
     def self.included(base)
       base.class_eval do
         alias_method_chain :table, :migration_comments
@@ -23,9 +24,12 @@ module MigrationComments::ActiveRecord
       lines = []
       table_line = 0
       col_names = {}
+      error = false
       while (line = stream.gets)
         content = line.chomp
-        if content =~ /create_table\s/
+        if content =~ /^# Could not dump table "#{table_name}"/
+          error = true
+        elsif content =~ /create_table\s/
           table_line = lines.size
         elsif content =~ /t\.\w+\s+"(\w+)"/
           col_names[lines.size] = $1.to_sym
@@ -34,7 +38,9 @@ module MigrationComments::ActiveRecord
       end
       len = col_names.keys.map{|index| lines[index]}.map(&:length).max + 2 unless col_names.empty?
       lines.each_with_index do |line, index|
-        if table_line == index && table_comment.present?
+        if error
+          # do nothing
+        elsif table_line == index && table_comment.present?
           block_init = " do |t|"
           line.chomp!(block_init) << ", " << render_comment(table_comment) << block_init
         elsif col_names[index]
@@ -46,9 +52,5 @@ module MigrationComments::ActiveRecord
       comment_stream.rewind
       comment_stream
     end
-
-    def render_comment(comment)
-      ":comment => \"#{comment}\""
-    end
   end
 end

data/lib/migration_comments/schema_formatter.rb

@@ -0,0 +1,19 @@
+module MigrationComments
+  module SchemaFormatter
+    def render_comment(comment)
+      render_kv_pair(:comment, comment)
+    end
+
+    def render_kv_pair(key, value)
+      if ::ActiveRecord::VERSION::MAJOR <= 3
+        ":#{key} => #{render_value(value)}"
+      else
+        "#{key}: #{render_value(value)}"
+      end
+    end
+
+    def render_value(value)
+      value.is_a?(String) ? "\"#{value}\"" : value
+    end
+  end
+end

data/lib/migration_comments/version.rb

@@ -1,3 +1,3 @@
 module MigrationComments
-  VERSION = "0.2.1"
+  VERSION = "0.3.0"
 end

data/migration_comments.gemspec

@@ -6,7 +6,7 @@ Gem::Specification.new do |s|
   s.name        = "migration_comments"
   s.version     = MigrationComments::VERSION
   s.authors     = ["Pinny"]
-  s.email       = ["pinny@medwiztech.com"]
+  s.email       = ["pinny@mwitz.com"]
   s.homepage    = "https://github.com/pinnymz/migration_comments"
   s.summary     = %q{Comments for your migrations}
   s.description = %q{Add schema comments in your migrations, see them in model annotations and db/schema.rb dump}
@@ -18,7 +18,7 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_runtime_dependency 'rails', '>= 2.3.2'
+  s.add_runtime_dependency 'activerecord', '>= 2.3.2'
 
   # for development, we are testing against the 'annotate' gem
   # however, the comments should work with the original 'annotate_models' plugin as well at:
@@ -26,9 +26,10 @@ Gem::Specification.new do |s|
   # provided the environment is not loaded until _after_ the AnnotateModels module is declared
   s.add_development_dependency 'annotate', '~> 2.5.0'
 
-  s.add_development_dependency 'pg' # replace with other adapter as needed
+  # add / replace with other adapter(s) as needed
+  s.add_development_dependency 'pg'
   # s.add_development_dependency 'postgres-pr'
   # s.add_development_dependency 'mysql'
-  # s.add_development_dependency 'mysql2'
-  # s.add_development_dependency 'sqlite3'
+  s.add_development_dependency 'mysql2'
+  s.add_development_dependency 'sqlite3'
 end

data/test/add_comments_test.rb

@@ -1,4 +1,4 @@
-require './test_helper'
+require File.join(File.dirname(__FILE__), 'test_helper')
 
 class AddCommentsTest < Test::Unit::TestCase
   include TestHelper
@@ -40,7 +40,7 @@ class AddCommentsTest < Test::Unit::TestCase
         result_table_comment = retrieve_table_comment :sample2
         result_column_comments = retrieve_column_comments :sample2
       ensure
-        drop_table :sample2
+        drop_table :sample2 rescue nil
       end
     end
     assert_equal table_comment, result_table_comment

data/test/annotate_models_test.rb

@@ -1,4 +1,4 @@
-require './test_helper'
+require File.join(File.dirname(__FILE__), 'test_helper')
 gem 'annotate'
 require 'annotate/annotate_models'
 

data/test/auto_increment_test.rb

@@ -1,4 +1,4 @@
-require './test_helper'
+require File.join(File.dirname(__FILE__), 'test_helper')
 
 class Sample < ActiveRecord::Base
   self.table_name = 'sample'

data/test/config/database.yml

@@ -6,13 +6,13 @@ postgres:
   password: postgres
 
 mysql:
-  adapter: mysql # mysql2
+  adapter: mysql2
   database: migration_comments_test
   user: root
   password: password
 
 sqlite:
   adapter: sqlite3
-  database: db/migration_comments_test
+  database: test/db/migration_comments_test
   pool: 5
   timeout: 5000

data/test/schema_dumper_test.rb

@@ -1,7 +1,8 @@
-require './test_helper'
+require File.join(File.dirname(__FILE__), 'test_helper')
 
 class SchemaDumperTest < Test::Unit::TestCase
   include TestHelper
+  include MigrationComments::SchemaFormatter
 
   def test_dump
     ActiveRecord::Schema.define do
@@ -14,23 +15,23 @@ class SchemaDumperTest < Test::Unit::TestCase
     dest.rewind
     result = dest.read
     expected = <<EOS
-ActiveRecord::Schema.define(:version => 1) do
+ActiveRecord::Schema.define(#{render_kv_pair(:version, 1)}) do
 
-  create_table "sample", :force => true, :comment => "a table comment" do |t|
-    t.string  "field1",                                 :comment => "a \"comment\" \\ that ' needs; escaping''"
+  create_table "sample", #{render_kv_pair(:force, true)}, #{render_kv_pair(:comment, "a table comment")} do |t|
+    t.string  "field1", __SPACES__#{render_kv_pair(:comment, %{a \"comment\" \\ that ' needs; escaping''})}
     t.integer "field2"
-    t.string  "field3", :default => "", :null => false, :comment => "third column comment"
+    t.string  "field3", #{render_kv_pair(:default, "")}, #{render_kv_pair(:null, false)}, #{render_kv_pair(:comment, "third column comment")}
   end
 
 end
 EOS
-
-    assert_match /#{Regexp.escape expected}/, result
+    assert_match /#{Regexp.escape(expected).gsub(/__SPACES__/, " +")}/, result
   end
 
   def test_dump_with_no_columns
     ActiveRecord::Schema.define do
-      remove_column :sample, :field1, :field2
+      remove_column :sample, :field1
+      remove_column :sample, :field2
       set_table_comment :sample, "a table comment"
     end
     dest = StringIO.new
@@ -38,11 +39,38 @@ EOS
     dest.rewind
     result = dest.read
     expected = <<EOS
-ActiveRecord::Schema.define(:version => 1) do
+ActiveRecord::Schema.define(#{render_kv_pair(:version, 1)}) do
 
-  create_table "sample", :force => true, :comment => "a table comment" do |t|
+  create_table "sample", #{render_kv_pair(:force, true)}, #{render_kv_pair(:comment, "a table comment")} do |t|
   end
 
+end
+EOS
+
+    assert_match /#{Regexp.escape expected}/, result
+  end
+
+  def test_schema_dump_with_custom_type_error_for_pg
+    return unless ENV['DB'] == 'postgres'
+    ActiveRecord::Base.connection.execute "DROP TYPE IF EXISTS my_custom_type; CREATE TYPE my_custom_type AS ENUM('thing1', 'thing2');"
+    ActiveRecord::Base.connection.execute "ALTER TABLE sample ALTER COLUMN field2 TYPE my_custom_type USING 'thing1';"
+
+    ActiveRecord::Schema.define do
+      set_table_comment :sample, "a table comment"
+      set_column_comment :sample, :field1, "column comment"
+    end
+
+    dest = StringIO.new
+    ActiveRecord::SchemaDumper.dump(ActiveRecord::Base.connection, dest)
+    dest.rewind
+    result = dest.read
+
+    expected = <<EOS
+ActiveRecord::Schema.define(#{render_kv_pair(:version, 1)}) do
+
+# Could not dump table "sample" because of following StandardError
+#   Unknown type 'my_custom_type' for column 'field2'
+
 end
 EOS
 

data/test/test_helper.rb

@@ -1,11 +1,11 @@
 require 'test/unit'
 
 require 'rubygems'
-gem 'rails', '>= 2.3.2'
+gem 'activerecord', '>= 2.3.2'
 require 'active_record'
 require 'yaml'
 
-CONFIGURATIONS = YAML::load(IO.read('config/database.yml'))
+CONFIGURATIONS = YAML::load(IO.read(File.join(File.dirname(__FILE__), 'config/database.yml')))
 
 ENV['DB'] ||= 'postgres' # override as needed
 

metadata

@@ -1,79 +1,104 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: migration_comments
-version: !ruby/object:Gem::Version 
-  hash: 21
-  prerelease: false
-  segments: 
-  - 0
-  - 2
-  - 1
-  version: 0.2.1
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+  prerelease: 
 platform: ruby
-authors: 
+authors:
 - Pinny
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-12-31 00:00:00 -05:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
-  name: rails
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
+date: 2013-07-05 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 7
-        segments: 
-        - 2
-        - 3
-        - 2
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
         version: 2.3.2
   type: :runtime
-  version_requirements: *id001
-- !ruby/object:Gem::Dependency 
-  name: annotate
   prerelease: false
-  requirement: &id002 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.3.2
+- !ruby/object:Gem::Dependency
+  name: annotate
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
+    requirements:
     - - ~>
-      - !ruby/object:Gem::Version 
-        hash: 27
-        segments: 
-        - 2
-        - 5
-        - 0
+      - !ruby/object:Gem::Version
         version: 2.5.0
   type: :development
-  version_requirements: *id002
-- !ruby/object:Gem::Dependency 
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.5.0
+- !ruby/object:Gem::Dependency
   name: pg
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
   prerelease: false
-  requirement: &id003 !ruby/object:Gem::Requirement 
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
     none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        hash: 3
-        segments: 
-        - 0
-        version: "0"
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
   type: :development
-  version_requirements: *id003
-description: Add schema comments in your migrations, see them in model annotations and db/schema.rb dump
-email: 
-- pinny@medwiztech.com
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Add schema comments in your migrations, see them in model annotations
+  and db/schema.rb dump
+email:
+- pinny@mwitz.com
 executables: []
-
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - .gitignore
 - Gemfile
 - MIT-LICENSE
@@ -81,17 +106,22 @@ files:
 - Rakefile
 - lib/migration_comments.rb
 - lib/migration_comments/active_record/connection_adapters/abstract_adapter.rb
+- lib/migration_comments/active_record/connection_adapters/abstract_adapter/schema_creation.rb
+- lib/migration_comments/active_record/connection_adapters/abstract_sqlite_adapter.rb
+- lib/migration_comments/active_record/connection_adapters/alter_table.rb
 - lib/migration_comments/active_record/connection_adapters/column.rb
 - lib/migration_comments/active_record/connection_adapters/column_definition.rb
 - lib/migration_comments/active_record/connection_adapters/comment_definition.rb
 - lib/migration_comments/active_record/connection_adapters/mysql2_adapter.rb
 - lib/migration_comments/active_record/connection_adapters/mysql_adapter.rb
 - lib/migration_comments/active_record/connection_adapters/postgresql_adapter.rb
+- lib/migration_comments/active_record/connection_adapters/sqlite3_adapter.rb
 - lib/migration_comments/active_record/connection_adapters/sqlite_adapter.rb
 - lib/migration_comments/active_record/connection_adapters/table.rb
 - lib/migration_comments/active_record/connection_adapters/table_definition.rb
 - lib/migration_comments/active_record/schema_dumper.rb
 - lib/migration_comments/annotate_models.rb
+- lib/migration_comments/schema_formatter.rb
 - lib/migration_comments/version.rb
 - migration_comments.gemspec
 - test/add_comments_test.rb
@@ -100,39 +130,34 @@ files:
 - test/config/database.yml
 - test/schema_dumper_test.rb
 - test/test_helper.rb
-has_rdoc: true
 homepage: https://github.com/pinnymz/migration_comments
 licenses: []
-
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
+required_ruby_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
       - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
+      hash: 1998391628422785254
+required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
-  requirements: 
-  - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
       - 0
-      version: "0"
+      hash: 1998391628422785254
 requirements: []
-
 rubyforge_project: migration_comments
-rubygems_version: 1.3.7
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Comments for your migrations
 test_files: []
-