migration_comments 0.3.2 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 766b7ebfb9c64bc9b8a4bc03e4c943d0276c6f49
-  data.tar.gz: c33c766bd47e849dc07d5c5b454eddeb1ce3278c
+  metadata.gz: a92efc84724b53b99d1938f473c3fcdfb835968b
+  data.tar.gz: a782dfc206d8e690c70eecffe2a13e6c265ea1cb
 SHA512:
-  metadata.gz: 5be5b935f97b70922631c45519bff6083fec3a9bc8fd6104c2f7f391aa888d0ac57fc413cb8a4ce3310eae1c15fa4bded524f9cc10a74ba20e5c1e85285a11a7
-  data.tar.gz: 22b2a9ec4daaa59bf52b7a4c53969cb4d98340844857f564e9dda63d4ed598145cf052696e6529ac70c739f11db879587c378f2933b3ddb939a9db4faf1498f4
+  metadata.gz: c64821061f120a5013ea7244994a85b9cc90a2f8d3f0a1acfa7933a42dcce44c31b06c6f31d872d9db874393215f5444954567a37781ba1c2c182531c0b09c52
+  data.tar.gz: 8b0a8d93451ac641c7090ba406bb9f24762f0afcd8501751274ac33d2be99c91257112cb7f8bf17107737bf50a39697ff3d8ee13e0e6177aa1bc980f56c39f42

data/.gitignore

@@ -3,4 +3,5 @@
 Gemfile.lock
 pkg/*
 .idea/*
-test/db/migration_comments_test
+test/db/migration_comments_test
+.byebug_history

data/.travis.yml

@@ -0,0 +1,27 @@
+sudo: required
+language: ruby
+rvm:
+  - 2.1.8
+  - 2.2.4
+  - 2.3.0
+gemfile:
+  - Gemfile
+  - gemfiles/rails4.gemfile
+  - gemfiles/rails5.gemfile
+services:
+  - mysql
+  - postgresql
+before_install:
+  - gem install bundler
+before_script:
+  - mysql -u root -e "create database migration_comments_test;"
+  - psql -U postgres -c "ALTER USER "postgres" WITH PASSWORD 'password';"
+  - PGPASSWORD=password psql -U postgres -c "create database migration_comments_test;"
+env:
+  - DB=postgres
+  - DB=mysql
+  - DB=sqlite
+matrix:
+  exclude:
+    - rvm: 2.1.8
+      gemfile: gemfiles/rails5.gemfile

data/README.rdoc

@@ -4,9 +4,18 @@ Comments for your migrations
 
 Tested on:
 
-ActiveRecord 4.x:: using Ruby 1.9.3 / 2.0
-ActiveRecord 3.x:: using Ruby 1.8.7 / 1.9.x / 2.0
-ActiveRecord 2.3.x (deprecated):: using Ruby 1.8.6 / 1.8.7
+ActiveRecord 5.0:: Using Ruby 2.2 and higher
+ActiveRecord 4.2:: using Ruby 2.1 and higher
+
+Status: {<img src="https://travis-ci.org/pinnymz/migration_comments.svg?branch=master" alt="Build Status" />}[https://travis-ci.org/pinnymz/migration_comments]
+
+== **IMPORTANT UPDATE**
+
+ActiveRecord 5.0 is introducing baked-in comment support, although not all features provided by this project have yet been completely implemented.
+This is expected to be rectified by ActiveRecord 5.1, and as such ActiveRecord 5.0 will likely be the last version for which this gem will work (or be needed).
+ActiveRecord 5.0 itself will be supported by this project, but many features are overlapping and you may find that you won't need it at all.
+
+For those using a version of ActiveRecord prior to 4.2 or of Ruby prior to 2.1, please use the v0.3.2 version of the gem.
 
 == Why?
 

data/Rakefile

@@ -1,8 +1,32 @@
 require "bundler/gem_tasks"
 require "rake/testtask"
 
+task :default => [:test]
+
 Rake::TestTask.new do |t|
   t.libs << "test"
   t.test_files = FileList['test/*_test.rb']
   t.verbose = true
 end
+
+namespace :test do
+  task all: [:postgres, :mysql, :sqlite]
+
+  task :postgres do
+    ENV['DB'] = 'postgres'
+    puts "\n\nrunning PostgreSQL tests..."
+    Rake::Task['test'].execute
+  end
+
+  task :mysql do
+    ENV['DB'] = 'mysql'
+    puts "\n\nrunning MySQL tests..."
+    Rake::Task['test'].execute
+  end
+
+  task :sqlite do
+    ENV['DB'] = 'sqlite'
+    puts "\n\nrunning SQLite tests..."
+    Rake::Task['test'].execute
+  end
+end

data/docker-compose.yml

@@ -0,0 +1,12 @@
+mysql:
+  image: "mysql:5.6"
+  ports:
+    - "3306:3306"
+  environment:
+    MYSQL_ROOT_PASSWORD: password
+postgres:
+  image: "postgres:9.4"
+  ports:
+    - "5432:5432"
+  environment:
+    POSTGRES_PASSWORD: postgres

data/gemfiles/rails4.gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+gem "activerecord", '~> 4.0'
+
+gemspec :path => '../'

data/gemfiles/rails5.gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+gem "activerecord", '~> 5.0.0.rc1'
+
+gemspec :path => '../'

data/lib/migration_comments.rb

@@ -10,76 +10,48 @@ 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}"}
+        %w(AbstractAdapter AbstractAdapter::SchemaCreation AlterTable ColumnDefinition Column Table TableDefinition).map{|name| "ConnectionAdapters::#{name}"}
 
     base_names.each do |base_name|
       ar_class = "ActiveRecord::#{base_name}".constantize
       mc_class = "MigrationComments::ActiveRecord::#{base_name}".constantize
-      unless ar_class.ancestors.include?(mc_class)
-        ar_class.__send__(:include, mc_class)
-      end
-    end
-
-    # 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
+      unless ar_class.descendants.include?(mc_class)
+        ar_class.prepend mc_class
       end
     end
 
-    adapters = %w(PostgreSQL Mysql Mysql2)
-    adapters << (::ActiveRecord::VERSION::MAJOR <= 3 ? "SQLite" : "SQLite3")
+    adapters = %w(PostgreSQL Mysql2 SQLite3)
     adapters.each do |adapter|
       begin
         require("active_record/connection_adapters/#{adapter.downcase}_adapter")
         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)
+        unless adapter_class.descendants.include?(mc_class)
+          adapter_class.prepend mc_class
         end
-      rescue Exception => ex
+      rescue
       end
     end
 
     # annotations are not required for this gem, but if they exist they should be updated
     begin
-      begin # first try to load from the 'annotate' gem
-        require 'annotate/annotate_models'
-      rescue Exception => ex
-        # continue as it may be already accessible through a plugin
-      end
-      gem_class = AnnotateModels
-      # don't require this until after the original AnnotateModels loads to avoid namespace confusion
+      require 'annotate/annotate_models'
+      gem_class = ::AnnotateModels
       require 'migration_comments/annotate_models'
       mc_class = MigrationComments::AnnotateModels
       unless gem_class.ancestors.include?(mc_class)
-        gem_class.__send__(:include, mc_class)
+        gem_class.prepend mc_class
       end
-    rescue Exception => ex
+    rescue
+      debugger
       # if we got here, don't bother installing comments into annotations
     end
   end

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

@@ -6,15 +6,6 @@ module MigrationComments::ActiveRecord::ConnectionAdapters
     def set_column_comment(table_name, column_name, comment_text)
     end
 
-    def add_table_comment(*args)
-      puts "'add_table_comment' is deprecated, and will be removed in future releases. Use 'set_table_comment' instead."
-      set_table_comment(*args)
-    end
-    def add_column_comment(*args)
-      puts "'add_column_comment' is deprecated, and will be removed in future releases. Use 'set_column_comment' instead."
-      set_column_comment(*args)
-    end
-
     def comments_supported?
       false
     end
@@ -24,7 +15,7 @@ module MigrationComments::ActiveRecord::ConnectionAdapters
       false
     end
 
-    # PostgreSQL style - comment specific commands
+    # PostgreSQL style - comment-specific commands
     def independent_comments?
       false
     end

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

@@ -1,48 +1,45 @@
 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 :add_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
+    def column_options(o)
+      column_options = super(o)
+      column_options[:comment] = o.comment.comment_text if o.comment.respond_to?(:comment_text)
       column_options
     end
 
-    def add_column_options_with_migration_comments!(sql, options)
-      sql = add_column_options_without_migration_comments!(sql, options)
+    def add_column_options!(sql, options)
+      sql = super(sql, options)
       if options.keys.include?(:comment) && !@conn.independent_comments?
-        sql <<  MigrationComments::ActiveRecord::ConnectionAdapters::CommentDefinition.new(@conn, nil, nil, options[:comment]).to_sql
+        comment_definition = MigrationComments::ActiveRecord::ConnectionAdapters::CommentDefinition.new(nil, nil, options[:comment])
+        sql << @conn.comment_sql(comment_definition)
       end
       sql
     end
 
-    def visit_TableDefinition_with_migration_comments(o)
+    def visit_TableDefinition(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 << "#{quote_table_name(o.name)}#{@conn.comment_sql(o.comment)} ("
         create_sql << o.columns.map { |c| accept c }.join(', ')
         create_sql << ") #{o.options}"
         create_sql
       else
-        visit_TableDefinition_without_migration_comments(o)
+        super(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
+    def visit_ColumnDefinition(o)
+      if @conn.inline_comments? && o.type.to_sym == :primary_key && o.comment
+        if ::ActiveRecord::VERSION::MAJOR >= 5
+          comment_sql = super(o)
+          comment_sql << @conn.comment_sql(o.comment)
+        else
+          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
+        end
       else
-        visit_ColumnDefinition_without_migration_comments(o)
+        super(o)
       end
     end
   end

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

@@ -1,16 +1,11 @@
 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)
+    def add_column(name, type, options)
+      super(name, type, options)
       if options.keys.include?(:comment)
-        column = @adds.last
-        column.comment = CommentDefinition.new(nil, @td, name, options[:comment])
+        added_entity = @adds.last
+        column = added_entity.respond_to?(:column) ? added_entity.column : added_entity
+        column.comment = CommentDefinition.new(@td, name, options[:comment])
       end
     end
   end

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

@@ -1,9 +1,5 @@
 module MigrationComments::ActiveRecord::ConnectionAdapters
   module Column
-    def self.included(base)
-      base.class_eval do
-        attr_accessor :comment
-      end
-    end
+    attr_accessor :comment
   end
 end

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

@@ -1,22 +1,14 @@
 module MigrationComments::ActiveRecord::ConnectionAdapters
-  class CommentDefinition < Struct.new(:adapter, :table, :column_name, :comment_text)
+  class CommentDefinition < Struct.new(:table_name, :column_name, :comment_text)
     def to_dump
       table_comment? ?
           "set_table_comment :#{table_name}, %{#{comment_text}}" :
           "set_column_comment :#{table_name}, :#{column_name}, %{#{comment_text}}"
     end
 
-    def to_sql
-      adapter.comment_sql(self)
-    end
-    alias to_s :to_sql
-
     def table_comment?
       column_name.blank?
     end
 
-    def table_name
-      table.respond_to?(:name) ? table.name : table
-    end
   end
 end

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

@@ -1,9 +1,103 @@
 module MigrationComments::ActiveRecord::ConnectionAdapters
   module Mysql2Adapter
-    def self.included(base)
-      base.class_eval do
-        include MigrationComments::ActiveRecord::ConnectionAdapters::MysqlAdapter
+
+    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
+
+    def set_column_comment(table_name, column_name, comment_text)
+      column = column_for(table_name, column_name)
+      options = {
+        comment: comment_text,
+        auto_increment: !!(column.extra =~ /auto_increment/)      # MySQL adapter drops this on calls to change_column
+      }
+      change_column table_name, column_name, column.sql_type, options
+    end
+
+    if ::ActiveRecord::VERSION::MAJOR >= 5
+      def add_sql_comment!(sql, comment)
+        comment_text = comment.respond_to?(:comment_text) ? comment.comment_text : comment
+        super(sql, comment_text)
+      end
+    end
+
+    def retrieve_table_comment(table_name)
+      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)) || []
+      Hash[result.map{|row| [row[0].to_sym, row[1].presence]}]
+    end
+
+    def create_table(table_name, options={})
+      local_table_definition = nil
+      super(table_name, options) do |td|
+        local_table_definition = td
+        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 comment_definition
+      end
+    end
+
+    def change_column(table_name, column_name, type, options={})
+      unless options.keys.include?(:comment)
+        options.merge!(:comment => retrieve_column_comment(table_name, column_name))
       end
+      super(table_name, column_name, type, options)
+    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
+
+    def comment_sql(comment_definition)
+      " COMMENT #{escaped_comment(comment_definition.comment_text)}"
+    end
+
+    def execute_comment(comment_definition)
+      if comment_definition.table_comment?
+        set_table_comment comment_definition.table_name, comment_definition.comment_text
+      else
+        set_column_comment comment_definition.table_name, comment_definition.column_name, comment_definition.comment_text
+      end
+    end
+
+    private
+    def escaped_comment(comment)
+      comment.nil? ? "''" : "'#{comment.gsub("'", "''").gsub("\\", "\\\\\\\\")}'"
+    end
+
+    def table_comment_sql(table_name)
+      <<SQL
+SELECT table_comment FROM INFORMATION_SCHEMA.TABLES
+  WHERE table_schema = '#{database_name}'
+  AND table_name = '#{table_name}'
+SQL
+    end
+
+    def column_comment_sql(table_name, *column_names)
+      col_matcher_sql = " AND column_name IN (#{column_names.map{|c_name| "'#{c_name}'"}.join(',')})" unless column_names.empty?
+      <<SQL
+SELECT column_name, column_comment FROM INFORMATION_SCHEMA.COLUMNS
+  WHERE table_schema = '#{database_name}'
+  AND table_name = '#{table_name}' #{col_matcher_sql}
+SQL
+    end
+
+    def database_name
+      @database_name ||= select_value("SELECT DATABASE()")
     end
+
   end
 end