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,18 +351,23 @@ 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)
       old_content = File.read(file_name)
       return false if old_content =~ /#{SKIP_ANNOTATION_PREFIX}.*\n/
 
       # Ignore the Schema version line because it changes with each migration
+      # TODO: may need look at this for Yard and RDoc as well
       header_pattern = /(^# Table name:.*?\n(#.*[\r]?\n)*[\r]?)/
       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,86 @@ 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(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
+            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
+      end
     end
 
     describe 'with existing annotation => :before' do