Fixes updating columns when using alternative formats

Updates `column_pattern` in `AnnotateModels.annotate_one_file` to
support RDoc and Yard doc formats. `column_pattern` is responsible for
searching for existing annotations in the file - if the patten is not
matched in file, annotations are not updated.

Since the previous regular expression did not match the Yard
(`@!`) or RDoc (`**<attributed>**::`), when attempting to update
annotations for a model, it would look like there were no changes since
parsing the annotation blocks with the regular expression would return
nothing.

Author: tmr08c

lib/annotate/annotate_models.rb

@@ -351,6 +351,10 @@ def get_foreign_key_info(klass, options = {})
     #  :force<Symbol>:: whether to update the file even if it doesn't seem to need it.
     #  :position_in_*<Symbol>:: where to place the annotated section in fixture or model file,
     #                           :before, :top, :after or :bottom. Default is :before.
+    #  :format_bare<Boolean>:: whether to format annotations using default, bare syntax
+    #  :format_markdown<Boolean>:: whether to format annotations using Markdown syntax
+    #  :format_rdoc<Boolean>:: whether to format annotations using RDoc syntax
+    #  :format_yard<Boolean>:: whether to format annotations using Yard syntax
     #
     def annotate_one_file(file_name, info_block, position, options = {})
       return false unless File.exist?(file_name)
@@ -362,7 +366,7 @@ def annotate_one_file(file_name, info_block, position, options = {})
       old_header = old_content.match(header_pattern).to_s
       new_header = info_block.match(header_pattern).to_s
 
-      column_pattern = /^#[\t ]+[\w\*\.`]+[\t ]+.+$/
+      column_pattern = /^#[\t ]+[\w\*\.\`\@\!\:]+[\t ]+.+$/
       old_columns = old_header && old_header.scan(column_pattern).sort
       new_columns = new_header && new_header.scan(column_pattern).sort
 

spec/lib/annotate/annotate_models_spec.rb

@@ -2515,6 +2515,93 @@ def annotate_one_file(options = {})
           expect(File.read(@model_file_name)).to eq("#{@schema_info}#{@file_content}")
         end
       end
+
+      context 'adding a new field' do
+        let(:class_name) { :users }
+        let(:primary_key) { :id }
+        let(:original_columns) do
+          [
+            mock_column(primary_key, :integer),
+            mock_column(:name, :string)
+          ]
+        end
+
+        before do
+          klass = mock_class(class_name, primary_key, original_columns)
+          @schema_info = AnnotateModels.get_schema_info(klass, '== Schema Info', options)
+          annotate_one_file(options)
+
+          # confirm we initialized annotaions in file before checking for changes
+          expect(@schema_info).not_to be_empty
+          expect(File.read(@model_file_name)).to eq("#{@schema_info}#{@file_content}")
+        end
+
+        context 'when option "format_bare" is true' do
+          let :options do
+            { format_bare: true }
+          end
+
+          it 'updates the fields list to include the new column' do
+            new_column_list = original_columns + [mock_column(:new_column, :string)]
+            klass = mock_class(class_name, primary_key, new_column_list)
+            @schema_info = AnnotateModels.get_schema_info(klass, '== Schema Info', options)
+            annotate_one_file(options)
+
+            expect(File.read(@model_file_name)).to eq("#{@schema_info}#{@file_content}")
+          end
+        end
+
+        context 'when option "format_yard" is true' do
+          let :options do
+            { format_yard: true }
+          end
+
+          it 'updates the fields list to include the new column' do
+            new_column_list = original_columns + [mock_column(:new_column, :string)]
+            klass = mock_class(class_name, primary_key, new_column_list)
+            @schema_info = AnnotateModels.get_schema_info(klass, '== Schema Info', options)
+            annotate_one_file(options)
+
+            expect(File.read(@model_file_name)).to eq("#{@schema_info}#{@file_content}")
+          end
+        end
+
+        context 'when option "format_rdoc" is true' do
+          let :options do
+            { format_rdoc: true }
+          end
+
+          it 'updates the fields list to include the new column' do
+            new_column_list = original_columns + [mock_column(:new_column, :string)]
+            klass = mock_class(class_name, primary_key, new_column_list)
+            @schema_info = AnnotateModels.get_schema_info(klass, '== Schema Info', options)
+            annotate_one_file(options)
+
+            expect(File.read(@model_file_name)).to eq("#{@schema_info}#{@file_content}")
+          end
+        end
+
+        context 'when option "format_markdown" is true' do
+          let :options do
+            { format_markdown: true }
+          end
+
+          it 'updates the fields list to include the new column' do
+            # The new column name must be shorter than the existing columns
+            # becuase markdown formatting adds additional spacing. If the
+            # column name is long, the header row has space added triggering a
+            # difference even if we don't properly check the columns. By having
+            # a shorter column name we are testing our column list comparison
+            # and not an unintentional resizing.
+            new_column_list = original_columns + [mock_column(:a, :string)]
+            klass = mock_class(class_name, primary_key, new_column_list)
+            @schema_info = AnnotateModels.get_schema_info(klass, '== Schema Info', options)
+            annotate_one_file(options)
+
+            expect(File.read(@model_file_name)).to eq("#{@schema_info}#{@file_content}")
+          end
+        end
+      end
     end
 
     describe 'with existing annotation => :before' do