add table comment annotation

use hash parameter for fixing rubocop error 'Metrics/ParameterLists: Avoid parameter lists longer than 5 parameters. [6/5]'

Author: TomohikoSato

lib/annotate/annotate_models.rb

@@ -182,13 +182,16 @@ def get_schema_info(klass, header, options = {})
     end
 
     def get_schema_header_text(klass, options = {})
+      table_comment = with_table_comments?(klass, options) ? "(#{klass.connection.table_comment(klass.table_name)})" : ''
+      table_name = klass.table_name.to_s + table_comment
+
       info = "#\n"
       if options[:format_markdown]
-        info << "# Table name: `#{klass.table_name}`\n"
+        info << "# Table name: `#{table_name}`\n"
         info << "#\n"
         info << "# ### Columns\n"
       else
-        info << "# Table name: #{klass.table_name}\n"
+        info << "# Table name: #{table_name}\n"
       end
       info << "#\n"
     end
@@ -762,6 +765,12 @@ def with_comments?(klass, options)
         klass.columns.any? { |col| !col.comment.nil? }
     end
 
+    def with_table_comments?(klass, options)
+      options[:with_comment] &&
+        klass.connection.respond_to?(:table_comment) &&
+        klass.connection.table_comment(klass.table_name).present?
+    end
+
     def max_schema_info_width(klass, options)
       cols = columns(klass, options)
 

spec/lib/annotate/annotate_models_spec.rb

@@ -41,22 +41,26 @@ def mock_foreign_key(name, from_column, to_table, to_column = 'id', constraints
            on_update:    constraints[:on_update])
   end
 
-  def mock_connection(indexes = [], foreign_keys = [])
-    double('Conn',
-           indexes:      indexes,
-           foreign_keys: foreign_keys,
-           supports_foreign_keys?: true)
+  def mock_connection(options)
+    default_options = {
+      indexes:                [],
+      foreign_keys:           [],
+      supports_foreign_keys?: true,
+      table_comment:          nil
+    }
+
+    double('Conn', default_options.merge(options))
   end
 
-  def mock_class(table_name, primary_key, columns, indexes = [], foreign_keys = [])
+  def mock_class(table_name, primary_key, columns, connection_options: {})
     options = {
-      connection:       mock_connection(indexes, foreign_keys),
-      table_exists?:    true,
-      table_name:       table_name,
-      primary_key:      primary_key,
-      column_names:     columns.map { |col| col.name.to_s },
-      columns:          columns,
-      column_defaults:  Hash[columns.map { |col| [col.name, col.default] }],
+      connection:        mock_connection(connection_options),
+      table_exists?:     true,
+      table_name:        table_name,
+      primary_key:       primary_key,
+      column_names:      columns.map { |col| col.name.to_s },
+      columns:           columns,
+      column_defaults:   Hash[columns.map { |col| [col.name, col.default] }],
       table_name_prefix: ''
     }
 
@@ -217,7 +221,14 @@ def mock_column(name, type, options = {})
     end
 
     let :klass do
-      mock_class(:users, primary_key, columns, indexes, foreign_keys)
+      mock_class(:users,
+                 primary_key,
+                 columns,
+                 connection_options: {
+                   indexes: indexes,
+                   foreign_keys: foreign_keys,
+                   table_comment: table_comment
+                 })
     end
 
     let :indexes do
@@ -228,6 +239,10 @@ def mock_column(name, type, options = {})
       []
     end
 
+    let :table_comment do
+      nil
+    end
+
     context 'when option is not present' do
       let :options do
         {}
@@ -400,7 +415,13 @@ def mock_column(name, type, options = {})
               end
 
               let :klass do
-                mock_class(:posts, primary_key, columns, indexes, foreign_keys).tap do |mock_klass|
+                mock_class(:posts,
+                           primary_key,
+                           columns,
+                           connection_options: {
+                             indexes: indexes,
+                             foreign_keys: foreign_keys
+                           }).tap do |mock_klass|
                   allow(mock_klass).to receive(:translation_class).and_return(translation_klass)
                 end
               end
@@ -1061,6 +1082,33 @@ def mock_column(name, type, options = {})
                   { with_comment: 'yes' }
                 end
 
+                context 'when table have comments' do
+                  let :table_comment do
+                    'users table comment'
+                  end
+
+                  let :columns do
+                    [
+                      mock_column(:id, :integer, limit: 8),
+                    ]
+                  end
+
+                  let :expected_result do
+                    <<~EOS
+                      # Schema Info
+                      #
+                      # Table name: users(users table comment)
+                      #
+                      #  id :integer          not null, primary key
+                      #
+                    EOS
+                  end
+
+                  it 'works with option "with_comment"' do
+                    is_expected.to eq expected_result
+                  end
+                end
+
                 context 'when columns have comments' do
                   let :columns do
                     [
@@ -2566,14 +2614,16 @@ def annotate_one_file(options = {})
                                mock_column(:id, :integer),
                                mock_column(:foreign_thing_id, :integer)
                              ],
-                             [],
-                             [
-                               mock_foreign_key('fk_rails_cf2568e89e',
-                                                'foreign_thing_id',
-                                                'foreign_things',
-                                                'id',
-                                                on_delete: :cascade)
-                             ])
+                             connection_options: {
+                               indexes: [],
+                               foreign_keys: [
+                                 mock_foreign_key('fk_rails_cf2568e89e',
+                                                  'foreign_thing_id',
+                                                  'foreign_things',
+                                                  'id',
+                                                  on_delete: :cascade)
+                               ]
+                             })
           @schema_info = AnnotateModels.get_schema_info(klass, '== Schema Info', show_foreign_keys: true)
           annotate_one_file
         end
@@ -2585,14 +2635,16 @@ def annotate_one_file(options = {})
                                mock_column(:id, :integer),
                                mock_column(:foreign_thing_id, :integer)
                              ],
-                             [],
-                             [
-                               mock_foreign_key('fk_rails_cf2568e89e',
-                                                'foreign_thing_id',
-                                                'foreign_things',
-                                                'id',
-                                                on_delete: :restrict)
-                             ])
+                             connection_options: {
+                               indexes: [],
+                               foreign_keys: [
+                                 mock_foreign_key('fk_rails_cf2568e89e',
+                                                  'foreign_thing_id',
+                                                  'foreign_things',
+                                                  'id',
+                                                  on_delete: :restrict)
+                               ]
+                             })
           @schema_info = AnnotateModels.get_schema_info(klass, '== Schema Info', show_foreign_keys: true)
           annotate_one_file
           expect(File.read(@model_file_name)).to eq("#{@schema_info}#{@file_content}")