migration_comments 0.3.2 → 0.4.0

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

@@ -1,12 +1,5 @@
 module MigrationComments::ActiveRecord::ConnectionAdapters
   module PostgreSQLAdapter
-    def self.included(base)
-      base.class_eval do
-        alias_method_chain :create_table, :migration_comments
-        alias_method_chain :add_column, :migration_comments
-        alias_method_chain :change_column, :migration_comments
-      end
-    end
 
     def comments_supported?
       true
@@ -18,48 +11,52 @@ module MigrationComments::ActiveRecord::ConnectionAdapters
 
     # Set a comment on a table
     def set_table_comment(table_name, comment_text)
-      execute CommentDefinition.new(self, table_name, nil, comment_text).to_sql
+      execute comment_sql(CommentDefinition.new(table_name, nil, comment_text))
     end
 
     # Set a comment on a column
     def set_column_comment(table_name, column_name, comment_text)
-      execute CommentDefinition.new(self, table_name, column_name, comment_text).to_sql
+      execute comment_sql(CommentDefinition.new(table_name, column_name, comment_text))
+    end
+
+    if ::ActiveRecord::VERSION::MAJOR >= 5
+      def change_column_comment(table_name, column_name, comment)
+        comment_text = comment.respond_to?(:comment_text) ? comment.comment_text : comment
+        super(table_name, column_name, comment_text)
+      end
     end
 
     def retrieve_table_comment(table_name)
-      result = select_rows(table_comment_sql(table_name))
-      result[0].nil? ? nil : result[0][0]
+      select_value(table_comment_sql(table_name)).presence
     end
 
     def retrieve_column_comments(table_name, *column_names)
       result = select_rows(column_comment_sql(table_name, *column_names))
-      return {} if result.nil?
-      return result.inject({}){|m, row| m[row[0].to_sym] = row[1]; m}
+      Hash[result.map{|row| [row[0].to_sym, row[1].presence]}]
     end
 
-    def create_table_with_migration_comments(table_name, options = {})
+    def create_table(table_name, options = {})
       local_table_definition = nil
-      create_table_without_migration_comments(table_name, options) do |td|
+      super(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)
+        local_table_definition.comment = options[:comment] if options.has_key?(:comment)
         yield td if block_given?
       end
       comments = local_table_definition.collect_comments(table_name)
       comments.each do |comment_definition|
-        execute comment_definition.to_sql
+        execute comment_sql(comment_definition)
       end
     end
 
-    def add_column_with_migration_comments(table_name, column_name, type, options = {})
-      add_column_without_migration_comments(table_name, column_name, type, options)
+    def add_column(table_name, column_name, type, options = {})
+      super(table_name, column_name, type, options)
       if options[:comment]
         set_column_comment(table_name, column_name, options[:comment])
       end
     end
 
-    def change_column_with_migration_comments(table_name, column_name, type, options = {})
-      change_column_without_migration_comments(table_name, column_name, type, options)
+    def change_column(table_name, column_name, type, options = {})
+      super(table_name, column_name, type, options)
       if options.keys.include?(:comment)
         set_column_comment(table_name, column_name, options[:comment])
       end

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

@@ -1,40 +1,50 @@
 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
+    def comments_supported?
+      true
     end
 
-    def create_table(table_name, options = {})
-      td = create_table_definition table_name, options[:temporary], options[:options]
-      td.base = self
+    def inline_comments?
+      true
+    end
 
-      unless options[:id] == false
-        pk = options.fetch(:primary_key) {
-          ActiveRecord::Base.get_primary_key table_name.to_s.singularize
-        }
+    def set_table_comment(table_name, comment_text)
+      alter_table(table_name, :comment => comment_text)
+    end
 
-        td.primary_key pk, options.fetch(:id, :primary_key), options
-      end
-      td.comment options[:comment] if options.has_key?(:comment)
+    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
 
-      yield td if block_given?
+    def retrieve_table_comment(table_name)
+      result = select_value(lookup_comment_sql(table_name))
+      $1 if result =~ /CREATE (?:TEMPORARY )?TABLE #{quote_table_name table_name} [^\(]*\/\*(.*)\*\/ \(/
+    end
 
-      if options[:force] && table_exists?(table_name)
-        drop_table(table_name, options)
+    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_value(lookup_comment_sql(table_name))
+      result =~ /^CREATE (?:TEMPORARY )?TABLE "\w*" [^\(]*(?:\/\*.*\*\/ )?\((.*)\)[^\)]*$/
+      col_defs = $1
+      comment_matches = col_defs.scan(/"([^",]+)"[^,]*\/\*(.+?)\*\//)
+      Hash[comment_matches.map{|col_name, comment| [col_name.to_sym, comment.presence] }]
+    end
 
-      execute schema_creation.accept td
-      td.indexes.each_pair { |c,o| add_index table_name, c, o }
+    def create_table(table_name, options = {})
+      super(table_name, options) do |td|
+        td.comment = options[:comment] if options.has_key?(:comment)
+        yield td if block_given?
+      end
     end
 
-    def columns_with_migration_comments(table_name)
-      cols = columns_without_migration_comments(table_name)
+    def columns(table_name)
+      cols = super(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)
@@ -42,34 +52,51 @@ module MigrationComments::ActiveRecord::ConnectionAdapters
       cols
     end
 
-    def copy_table_with_migration_comments(from, to, options = {}) #:nodoc:
-      from_primary_key = primary_key(from)
-      options[:id] = false
+    def copy_table(from, to, options = {}) #:nodoc:
       unless options.has_key?(:comment)
         table_comment = retrieve_table_comment(from)
-        options = options.merge(:comment => table_comment) if table_comment
+        options.merge!(comment: table_comment) if table_comment
+      end
+      super(from, to, options) do |definition|
+        retrieve_column_comments(from).each do |col_name, comment|
+          definition[col_name].comment = CommentDefinition.new(from, col_name, comment)
+        end
+        yield definition if block_given?
       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
+    end
 
-          @definition.column(column_name, column.type,
-                             :limit => column.limit, :default => column.default,
-                             :precision => column.precision, :scale => column.scale,
-                             :null => column.null, :comment => column.comment)
+    def change_column(table_name, column_name, type, options = {}) #:nodoc:
+      super(table_name, column_name, type, options)
+      if options.has_key?(:comment)
+        alter_table(table_name) do |definition|
+          definition[column_name].comment = CommentDefinition.new(table_name, column_name, options[: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
+
+    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 << comment_sql(CommentDefinition.new(nil, nil, options[:comment]))
+      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.rb

@@ -1,12 +1,12 @@
 module MigrationComments::ActiveRecord::ConnectionAdapters
   module Table
     def change_comment(column_name, comment_text)
-      @base.set_column_comment(@table_name, column_name, comment_text)
+      @base.set_column_comment(name, column_name, comment_text)
     end
 
     def change_table_comment(comment_text)
-      @base.set_table_comment(@table_name, comment_text)
+      @base.set_table_comment(name, comment_text)
     end
-    alias comment :change_table_comment
+    alias_method :comment, :change_table_comment
   end
 end

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

@@ -1,33 +1,24 @@
 module MigrationComments::ActiveRecord::ConnectionAdapters
   module TableDefinition
+    attr_accessor :comment
 
-    attr_accessor :table_comment
-    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)
-      self
+    def comment=(text)
+      @comment = text.respond_to?(:comment_text) ? text : CommentDefinition.new(nil, nil, text)
     end
 
-    def column_with_migration_comments(name, type, options = {})
-      column_without_migration_comments(name, type, options)
+    def column(name, type, options = {})
+      super(name, type, options)
       if options.has_key?(:comment)
         col = self[name]
-        col.comment = CommentDefinition.new(base, nil, name, options[:comment])
+        col.comment = CommentDefinition.new(nil, name, options[:comment])
       end
       self
     end
 
     def collect_comments(table_name)
-      comments = []
-      comments << @table_comment << columns.map(&:comment)
-      comments.flatten!.compact!
-      comments.each{|comment| comment.table = table_name; comment.adapter = base}
+      comments = [comment] + columns.map(&:comment)
+      comments.compact!
+      comments.each{|comment| comment.table_name = table_name }
     end
   end
 end

data/lib/migration_comments/active_record/schema_dumper.rb

@@ -1,15 +1,11 @@
 module MigrationComments::ActiveRecord
   module SchemaDumper
     include MigrationComments::SchemaFormatter
-    def self.included(base)
-      base.class_eval do
-        alias_method_chain :table, :migration_comments
-      end
-    end
 
-    def table_with_migration_comments(table, stream)
+    def table(table, stream)
+      return super if ::ActiveRecord::VERSION::MAJOR >= 5 && @connection.class.name !~ /SQLite/
       tbl_stream = StringIO.new
-      table_without_migration_comments(table, tbl_stream)
+      super(table, tbl_stream)
       tbl_stream.rewind
       commented_stream = append_comments(table, tbl_stream)
       tbl_stream.close
@@ -25,8 +21,8 @@ module MigrationComments::ActiveRecord
       table_line = 0
       col_names = {}
       error = false
-      while (line = stream.gets)
-        content = line.chomp
+      while (stream_line = stream.gets)
+        content = stream_line.chomp
         if content =~ /^# Could not dump table "#{table_name}"/
           error = true
         elsif content =~ /create_table\s/
@@ -43,7 +39,7 @@ module MigrationComments::ActiveRecord
         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]
+        elsif col_names[index] && ::ActiveRecord::VERSION::MAJOR < 5
           comment = column_comments[col_names[index]]
           line << ',' << ' ' * (len - line.length) << render_comment(comment) unless comment.blank?
         end

data/lib/migration_comments/annotate_models.rb

@@ -1,18 +1,16 @@
 module MigrationComments
   module AnnotateModels
-    def self.included(base)
-      base.class_eval do
-        class << self
-          include ClassMethods
-          alias_method_chain :get_schema_info, :migration_comments
-        end
+    def self.prepended(base)
+      class << base
+        prepend ClassMethods
       end
     end
 
     module ClassMethods
-      def get_schema_info_with_migration_comments(*args)
-        info = get_schema_info_without_migration_comments(*args)
+      def get_schema_info(*args)
         klass = args[0]
+        klass.reset_column_information
+        info = super(*args)
         commented_info(klass, info)
       end
 

data/lib/migration_comments/schema_formatter.rb

@@ -13,7 +13,14 @@ module MigrationComments
     end
 
     def render_value(value)
-      value.is_a?(String) ? %Q[#{value}].inspect : value
+      case value
+        when String
+          %Q[#{value}].inspect
+        when Symbol
+          value.inspect
+        else
+          value
+      end
     end
   end
 end

data/lib/migration_comments/version.rb

@@ -1,3 +1,3 @@
 module MigrationComments
-  VERSION = "0.3.2"
+  VERSION = "0.4.0"
 end

data/migration_comments.gemspec

@@ -18,18 +18,11 @@ 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 'activerecord', '>= 2.3.2'
+  s.add_runtime_dependency 'activerecord', '>= 4.2.0'
 
-  # for development, we are testing against the 'annotate' gem
-  # however, the comments should work with the original 'annotate_models' plugin as well at:
-  #  http://repo.pragprog.com/svn/Public/plugins/annotate_models
-  # provided the environment is not loaded until _after_ the AnnotateModels module is declared
-  s.add_development_dependency 'annotate', '~> 2.5.0'
-
-  # add / replace with other adapter(s) as needed
+  s.add_development_dependency 'annotate', '~> 2.7.0'
   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 'minitest-byebug'
 end

data/test/add_comments_test.rb

@@ -1,6 +1,6 @@
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-class AddCommentsTest < Minitest::Unit::TestCase
+class AddCommentsTest < Minitest::Test
   include TestHelper
 
   def test_adding_a_table_comment
@@ -26,10 +26,51 @@ class AddCommentsTest < Minitest::Unit::TestCase
     assert_nil result_field2
   end
 
+  def test_adding_a_column_with_a_comment
+    comment_text = "a comment in a new column"
+    result_field1 = nil
+    result_field3 = nil
+    ActiveRecord::Schema.define do
+      add_column :sample, :field3, :string, :comment => comment_text
+      result_field3 = retrieve_column_comment :sample, :field3
+      result_field1 = retrieve_column_comment :sample, :field1
+    end
+    assert_equal comment_text, result_field3
+    assert_nil result_field1
+  end
+
+  def test_changing_a_column_while_adding_a_comment
+    comment_text = "a comment in a changing column"
+    result_field1 = nil
+    ActiveRecord::Schema.define do
+      change_column :sample, :field1, :string, :limit => 25, :comment => comment_text
+      result_field1 = retrieve_column_comment :sample, :field1
+    end
+    assert_equal comment_text, result_field1
+  end
+
+  def test_creating_a_temp_table_with_table_comments_and_no_block
+    ActiveRecord::Schema.define do
+      begin
+        create_table :sample3, temporary: true, comment: "a table comment"
+      ensure
+        drop_table :sample3 rescue nil
+      end
+    end
+  end
+
   def test_creating_a_table_with_table_comments_and_no_block
+    table_comment = "a table comment"
+    result_table_comment = nil
     ActiveRecord::Schema.define do
-      create_table :sample3, :temporary => true, :comment => "a table comment"
+      begin
+        create_table :sample3, comment: table_comment
+        result_table_comment = retrieve_table_comment :sample3
+      ensure
+        drop_table :sample3 rescue nil
+      end
     end
+    assert_equal table_comment, result_table_comment
   end
 
   def test_creating_a_table_with_table_and_column_comments