annotaterb 4.5.0 → 4.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ab5413ba1fb4c02274c37e7629b0553deed339067624ef96e1ad9a59ecf726d1
-  data.tar.gz: 6439540d1c152651735313e80839acddc79d202d8b0171edb6c424e932dde37a
+  metadata.gz: 2c9e326fa73164a6a2e43edc402e6990cfbb5d953ac5fd1ccf8c71fa6d358ee1
+  data.tar.gz: dabf1afd54a8dec7a96ed8c259ca84e0a6085618713be78f43f075a51a22db7f
 SHA512:
-  metadata.gz: 40353034b577b5a44a1204edbb02e25d01b4d99efcb8de1a50fd8698981767c4f5444079b851441db60d16c175237e63f80453370f38007613aae1da5b613f71
-  data.tar.gz: 5edb0a811149b9187fd0b2066cf1843a84fde281239e2628ba643fa1ce4c906e914b387d4f461e62c84d5323e21a51223f3d5e838f5f4da300743180d6dabb8e
+  metadata.gz: 12e277c2d09e37e1001e64b0f08542ff03981bf5bbe37e86ed3dca01b1ec52c5b1805ce6f5cb1a8e5b25c3b9d655cb2345d0c9d878ecf4ae6bbfd265870445ac
+  data.tar.gz: 88d7c9ba17c3abbf38e635365314d1c4b372e67ec5ef0dcba9f7f4f5b6ef90d0e285a2150887127fa75f847a1ee2e8e4c7a30548729a4f903cf71f42be793177

data/CHANGELOG.md

@@ -1,5 +1,33 @@
 # Changelog
 
+## [v4.5.0](https://github.com/drwl/annotaterb/tree/v4.5.0) (2024-02-08)
+
+[Full Changelog](https://github.com/drwl/annotaterb/compare/v4.4.1...v4.5.0)
+
+**Closed issues:**
+
+- Add an automated way to migrate from the old annotate gem [\#73](https://github.com/drwl/annotaterb/issues/73)
+- Default array value is double-quoted/escaped [\#57](https://github.com/drwl/annotaterb/issues/57)
+
+**Merged pull requests:**
+
+- Bump version to v4.5.0 [\#79](https://github.com/drwl/annotaterb/pull/79) ([drwl](https://github.com/drwl))
+- Update README on the new Rails generator commands [\#78](https://github.com/drwl/annotaterb/pull/78) ([drwl](https://github.com/drwl))
+- Bump github/codeql-action from 2 to 3 [\#77](https://github.com/drwl/annotaterb/pull/77) ([dependabot[bot]](https://github.com/apps/dependabot))
+- Add command to generate a configuration file [\#76](https://github.com/drwl/annotaterb/pull/76) ([drwl](https://github.com/drwl))
+- Bump actions/checkout from 3 to 4 [\#75](https://github.com/drwl/annotaterb/pull/75) ([dependabot[bot]](https://github.com/apps/dependabot))
+- CI: Configure dependabot to update GH Actions [\#74](https://github.com/drwl/annotaterb/pull/74) ([olleolleolle](https://github.com/olleolleolle))
+- Refactor `FileBuilder` and `MagicCommentParser` [\#71](https://github.com/drwl/annotaterb/pull/71) ([drwl](https://github.com/drwl))
+- Test running annotations after a migration [\#70](https://github.com/drwl/annotaterb/pull/70) ([drwl](https://github.com/drwl))
+- Add integration test for rake task installer [\#69](https://github.com/drwl/annotaterb/pull/69) ([drwl](https://github.com/drwl))
+- Add integration test for annotating routes [\#68](https://github.com/drwl/annotaterb/pull/68) ([drwl](https://github.com/drwl))
+- Remove optional args [\#67](https://github.com/drwl/annotaterb/pull/67) ([drwl](https://github.com/drwl))
+- Remove optional arg from `AnnotationPatternGenerator` [\#66](https://github.com/drwl/annotaterb/pull/66) ([drwl](https://github.com/drwl))
+- Remove `ARGV` use during runtime [\#65](https://github.com/drwl/annotaterb/pull/65) ([drwl](https://github.com/drwl))
+- Add integration test for annotating a singular file [\#64](https://github.com/drwl/annotaterb/pull/64) ([drwl](https://github.com/drwl))
+- Generate changelog for v4.4.1 [\#63](https://github.com/drwl/annotaterb/pull/63) ([drwl](https://github.com/drwl))
+- Add support for factory\_bot's default suffixed pattern [\#59](https://github.com/drwl/annotaterb/pull/59) ([drwl](https://github.com/drwl))
+
 ## [v4.4.1](https://github.com/drwl/annotaterb/tree/v4.4.1) (2023-09-11)
 
 [Full Changelog](https://github.com/drwl/annotaterb/compare/v4.4.0...v4.4.1)

data/VERSION

@@ -1 +1 @@
-4.5.0
+4.6.0

data/lib/annotate_rb/eager_loader.rb

@@ -8,8 +8,12 @@ module AnnotateRb
         options[:require].count > 0 && options[:require].each { |path| require path }
 
         if defined?(::Rails::Application)
-          klass = ::Rails::Application.send(:subclasses).first
-          klass.eager_load!
+          if defined?(::Zeitwerk)
+            # Delegate to Zeitwerk to load stuff as needed
+          else
+            klass = ::Rails::Application.send(:subclasses).first
+            klass.eager_load!
+          end
         else
           options[:model_dir].each do |dir|
             ::Rake::FileList["#{dir}/**/*.rb"].each do |fname|

data/lib/annotate_rb/model_annotator/annotated_file/generator.rb

@@ -5,29 +5,72 @@ module AnnotateRb
     module AnnotatedFile
       # Generates the file with fresh annotations
       class Generator
-        def initialize(file_components, annotation_position, options)
-          @file_components = file_components
+        def initialize(file_content, new_annotations, annotation_position, options)
           @annotation_position = annotation_position
           @options = options
 
-          @new_wrapped_annotations = wrapped_content(@file_components.new_annotations)
+          @new_wrapped_annotations = wrapped_content(new_annotations)
+
+          @new_annotations = new_annotations
+          @file_content = file_content
+
+          @parsed_file = FileParser::ParsedFile.new(@file_content, @new_annotations, options).parse
         end
 
+        # @return [String] Returns the annotated file content to be written back to a file
         def generate
           # Need to keep `.to_s` for now since the it can be either a String or Symbol
           annotation_write_position = @options[@annotation_position].to_s
 
+          # New method: first remove annotations
+          content_without_annotations = if @parsed_file.has_annotations?
+            @file_content.sub(@parsed_file.annotations_with_whitespace, "")
+          elsif @options[:force]
+            @file_content.sub(@parsed_file.annotations_with_whitespace, "")
+          else
+            @file_content
+          end
+
+          # We need to get class start and class end depending on the position
+          parsed = FileParser::CustomParser.new(content_without_annotations, "", 0).tap(&:parse)
+
           _content = if %w[after bottom].include?(annotation_write_position)
-            @file_components.magic_comments + (@file_components.pure_file_content.rstrip + "\n\n" + @new_wrapped_annotations)
-          elsif @file_components.magic_comments.empty?
-            @file_components.magic_comments + @new_wrapped_annotations + @file_components.pure_file_content.lstrip
+            content_annotated_after(parsed, content_without_annotations)
           else
-            @file_components.magic_comments + "\n" + @new_wrapped_annotations + @file_components.pure_file_content.lstrip
+            content_annotated_before(parsed, content_without_annotations, annotation_write_position)
           end
         end
 
         private
 
+        def content_annotated_before(parsed, content_without_annotations, write_position)
+          same_write_position = @parsed_file.has_annotations? && @parsed_file.annotation_position.to_s == write_position
+
+          # Could error if there's no class or module declaration
+          _constant_name, line_number_before = parsed.starts.first
+
+          content_with_annotations_written_before = []
+          content_with_annotations_written_before << content_without_annotations.lines[0...line_number_before]
+          content_with_annotations_written_before << $/ if @parsed_file.has_leading_whitespace? && same_write_position
+          content_with_annotations_written_before << @new_wrapped_annotations.lines
+          content_with_annotations_written_before << $/ if @parsed_file.has_trailing_whitespace? && same_write_position
+          content_with_annotations_written_before << content_without_annotations.lines[line_number_before..]
+
+          content_with_annotations_written_before.join
+        end
+
+        def content_annotated_after(parsed, content_without_annotations)
+          _constant_name, line_number_after = parsed.ends.last
+
+          content_with_annotations_written_after = []
+          content_with_annotations_written_after << content_without_annotations.lines[0..line_number_after]
+          content_with_annotations_written_after << $/
+          content_with_annotations_written_after << @new_wrapped_annotations.lines
+          content_with_annotations_written_after << content_without_annotations.lines[(line_number_after + 1)..]
+
+          content_with_annotations_written_after.join
+        end
+
         def wrapped_content(content)
           wrapper_open = if @options[:wrapper_open]
             "# #{@options[:wrapper_open]}\n"

data/lib/annotate_rb/model_annotator/annotated_file/updater.rb

@@ -5,22 +5,22 @@ module AnnotateRb
     module AnnotatedFile
       # Updates existing annotations
       class Updater
-        def initialize(file_components, annotation_position, options)
-          @file_components = file_components
-          @annotation_position = annotation_position
+        def initialize(file_content, new_annotations, _annotation_position, options)
           @options = options
 
-          @new_wrapped_annotations = wrapped_content(@file_components.new_annotations)
+          @new_annotations = new_annotations
+          @file_content = file_content
+
+          @parsed_file = FileParser::ParsedFile.new(@file_content, @new_annotations, options).parse
         end
 
+        # @return [String] Returns the annotated file content to be written back to a file
         def update
-          return "" if !@file_components.has_annotations?
-
-          annotation_pattern = AnnotationPatternGenerator.call(@options)
+          return "" if !@parsed_file.has_annotations?
 
-          new_annotation = @file_components.space_before_annotation + @new_wrapped_annotations + @file_components.space_after_annotation
+          new_annotation = wrapped_content(@new_annotations)
 
-          _content = @file_components.current_file_content.sub(annotation_pattern, new_annotation)
+          _content = @file_content.sub(@parsed_file.annotations, new_annotation)
         end
 
         private

data/lib/annotate_rb/model_annotator/file_name_resolver.rb

@@ -5,8 +5,13 @@ module AnnotateRb
     class FileNameResolver
       class << self
         def call(filename_template, model_name, table_name)
+          # e.g. with a model file name like "app/models/collapsed/example/test_model.rb"
+          # and using a collapsed `model_name` such as "collapsed/test_model"
+          model_name_without_namespace = model_name.split("/").last
+
           filename_template
             .gsub("%MODEL_NAME%", model_name)
+            .gsub("%MODEL_NAME_WITHOUT_NS%", model_name_without_namespace)
             .gsub("%PLURALIZED_MODEL_NAME%", model_name.pluralize)
             .gsub("%TABLE_NAME%", table_name || model_name.pluralize)
         end

data/lib/annotate_rb/model_annotator/file_parser/annotation_finder.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module AnnotateRb
+  module ModelAnnotator
+    module FileParser
+      class AnnotationFinder
+        COMPAT_PREFIX = "== Schema Info"
+        COMPAT_PREFIX_MD = "## Schema Info"
+        DEFAULT_ANNOTATION_ENDING = "#"
+
+        class MalformedAnnotation < StandardError; end
+
+        class NoAnnotationFound < StandardError; end
+
+        # Returns the line index (not the line number) that the annotation starts.
+        attr_reader :annotation_start
+        # Returns the line index (not the line number) that the annotation ends, inclusive.
+        attr_reader :annotation_end
+
+        attr_reader :parser
+
+        def initialize(content, wrapper_open, wrapper_close)
+          @content = content
+          @wrapper_open = wrapper_open
+          @wrapper_close = wrapper_close
+          @annotation_start = nil
+          @annotation_end = nil
+          @parser = nil
+        end
+
+        # Find the annotation's line start and line end
+        def run
+          # CustomParser returns line numbers as 0-indexed
+          @parser = FileParser::CustomParser.new(@content, "", 0).tap(&:parse)
+          comments = @parser.comments
+
+          start = comments.find_index { |comment, _| comment.include?(COMPAT_PREFIX) || comment.include?(COMPAT_PREFIX_MD) }
+          raise NoAnnotationFound if start.nil? # Stop execution because we did not find
+
+          if @wrapper_open
+            prev_comment, _prev_line_number = comments[start - 1]
+
+            # Change start to the line before if wrapper_open is defined and we find the wrapper open comment
+            if prev_comment&.include?(@wrapper_open)
+              start -= 1
+            end
+          end
+
+          # Find a contiguous block of comments from the starting point
+          ending = start
+          while ending < comments.size - 1
+            _comment, line_number = comments[ending]
+            _next_comment, next_line_number = comments[ending + 1]
+
+            if next_line_number - line_number == 1
+              ending += 1
+            else
+              break
+            end
+          end
+
+          raise MalformedAnnotation if start == ending
+
+          if @wrapper_close
+            if comments[ending].first.include?(@wrapper_close)
+              # We can end here because it's the end of the annotation block
+            else
+              # Walk back until we find the end of the annotation comment block or the wrapper close to be flexible
+              #  We check if @wrapper_close is a substring because `comments` contains strings with the comment character
+              while ending > start && comments[ending].first != DEFAULT_ANNOTATION_ENDING && !comments[ending].first.include?(@wrapper_close)
+                ending -= 1
+              end
+            end
+          else
+            # Walk back until we find the end of the annotation comment block
+            while ending > start && comments[ending].first != DEFAULT_ANNOTATION_ENDING
+              ending -= 1
+            end
+          end
+
+          # We want .last because we want the line indexes
+          @annotation_start = comments[start].last
+          @annotation_end = comments[ending].last
+
+          [@annotation_start, @annotation_end]
+        end
+
+        def annotation
+          @annotation ||=
+            begin
+              lines = @content.lines
+              lines[@annotation_start..@annotation_end].join
+            end
+        end
+
+        # Returns true if annotations are detected in the file content
+        def annotated?
+          @annotation_start && @annotation_end
+        end
+      end
+    end
+  end
+end

data/lib/annotate_rb/model_annotator/file_parser/custom_parser.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+require "ripper"
+
+module AnnotateRb
+  module ModelAnnotator
+    module FileParser
+      class CustomParser < Ripper
+        # Overview of Ripper: https://kddnewton.com/2022/02/14/formatting-ruby-part-1.html
+        # Ripper API: https://kddnewton.com/ripper-docs/
+
+        class << self
+          def parse(string)
+            _parser = new(string, "", 0).tap(&:parse)
+          end
+        end
+
+        attr_reader :comments
+
+        def initialize(input, ...)
+          super
+          @_stack_code_block = []
+          @_input = input
+          @_const_event_map = {}
+
+          @comments = []
+          @block_starts = []
+          @block_ends = []
+          @const_type_map = {}
+        end
+
+        def starts
+          @block_starts
+        end
+
+        def ends
+          @block_ends
+        end
+
+        def type_map
+          @const_type_map
+        end
+
+        def on_program(...)
+          {
+            comments: @comments,
+            starts: @block_starts,
+            ends: @block_ends,
+            type_map: @const_type_map
+          }
+        end
+
+        def on_const_ref(const)
+          add_event(__method__, const, lineno)
+          @block_starts << [const, lineno]
+          super
+        end
+
+        # Used for `class Foo::User`
+        def on_const_path_ref(_left, const)
+          add_event(__method__, const, lineno)
+          @block_starts << [const, lineno]
+          super
+        end
+
+        def on_module(const, _bodystmt)
+          add_event(__method__, const, lineno)
+          @const_type_map[const] = :module unless @const_type_map[const]
+          @block_ends << [const, lineno]
+          super
+        end
+
+        def on_class(const, _superclass, _bodystmt)
+          add_event(__method__, const, lineno)
+          @const_type_map[const] = :class unless @const_type_map[const]
+          @block_ends << [const, lineno]
+          super
+        end
+
+        # Gets the `RSpec` opening in:
+        # ```ruby
+        # RSpec.describe "Collapsed::TestModel" do
+        #   # Deliberately left empty
+        # end
+        # ```
+        # receiver: "RSpec", operator: ".", method: "describe"
+        def on_command_call(receiver, operator, method, args)
+          add_event(__method__, receiver, lineno)
+          @block_starts << [receiver, lineno]
+
+          # We keep track of blocks using a stack
+          @_stack_code_block << receiver
+          super
+        end
+
+        def on_method_add_block(method, block)
+          # When parsing a line with no explicit receiver, the method will be presented in an Array.
+          # It's not immediately clear why.
+          #
+          # Example:
+          # ```ruby
+          # describe "Collapsed::TestModel" do
+          #   # Deliberately left empty
+          # end
+          # ```
+          #
+          # => method = ["describe"]
+          if method.is_a?(Array) && method.size == 1
+            method = method.first
+          end
+
+          add_event(__method__, method, lineno)
+
+          if @_stack_code_block.last == method
+            @block_ends << [method, lineno]
+            @_stack_code_block.pop
+          else
+            @block_starts << [method, lineno]
+          end
+          super
+        end
+
+        def on_method_add_arg(method, args)
+          add_event(__method__, method, lineno)
+          @block_starts << [method, lineno]
+
+          # We keep track of blocks using a stack
+          @_stack_code_block << method
+          super
+        end
+
+        # Gets the `FactoryBot` line in:
+        # ```ruby
+        # FactoryBot.define do
+        #   factory :user do
+        #     ...
+        #   end
+        # end
+        # ```
+        def on_call(receiver, operator, message)
+          # We only want to add the parsed line if the beginning of the Ruby
+          if @block_starts.empty?
+            add_event(__method__, receiver, lineno)
+            @block_starts << [receiver, lineno]
+          end
+
+          super
+        end
+
+        # Gets the `factory` block start in:
+        # ```ruby
+        # factory :user, aliases: [:author, :commenter] do
+        #   ...
+        # end
+        # ```
+        def on_command(message, args)
+          add_event(__method__, message, lineno)
+          @block_starts << [message, lineno]
+
+          # We keep track of blocks using a stack
+          @_stack_code_block << message
+          super
+        end
+
+        # Matches the `end` in:
+        # ```ruby
+        # factory :user, aliases: [:author, :commenter] do
+        #   first_name { "John" }
+        #   last_name { "Doe" }
+        #   date_of_birth { 18.years.ago }
+        # end
+        # ```
+        def on_do_block(block_var, bodystmt)
+          if block_var.blank? && bodystmt.blank?
+            @block_ends << ["end", lineno]
+            add_event(__method__, "end", lineno)
+          end
+          super
+        end
+
+        def on_embdoc_beg(value)
+          add_event(__method__, value, lineno)
+          @comments << [value.strip, lineno]
+          super
+        end
+
+        def on_embdoc_end(value)
+          add_event(__method__, value, lineno)
+          @comments << [value.strip, lineno]
+          super
+        end
+
+        def on_embdoc(value)
+          add_event(__method__, value, lineno)
+          @comments << [value.strip, lineno]
+          super
+        end
+
+        def on_comment(value)
+          add_event(__method__, value, lineno)
+          @comments << [value.strip, lineno]
+          super
+        end
+
+        private
+
+        def add_event(event, const, lineno)
+          if !@_const_event_map[lineno]
+            @_const_event_map[lineno] = []
+          end
+
+          @_const_event_map[lineno] << [const, event]
+        end
+      end
+    end
+  end
+end

data/lib/annotate_rb/model_annotator/file_parser/parsed_file.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module AnnotateRb
+  module ModelAnnotator
+    module FileParser
+      class ParsedFile
+        SKIP_ANNOTATION_STRING = "# -*- SkipSchemaAnnotations"
+
+        def initialize(file_content, new_annotations, options)
+          @file_content = file_content
+          @file_lines = @file_content.lines
+          @new_annotations = new_annotations
+          @options = options
+        end
+
+        def parse
+          @finder = AnnotationFinder.new(@file_content, @options[:wrapper_open], @options[:wrapper_close])
+          has_annotations = false
+
+          begin
+            @finder.run
+            has_annotations = @finder.annotated?
+          rescue AnnotationFinder::NoAnnotationFound => _e
+          end
+
+          annotations = if has_annotations
+            @file_lines[(@finder.annotation_start)..(@finder.annotation_end)].join
+          else
+            ""
+          end
+
+          @diff = AnnotationDiffGenerator.new(annotations, @new_annotations).generate
+          @file_parser = @finder.parser
+
+          has_skip_string = @file_parser.comments.any? { |comment, _lineno| comment.include?(SKIP_ANNOTATION_STRING) }
+          annotations_changed = @diff.changed?
+
+          has_leading_whitespace = false
+          has_trailing_whitespace = false
+
+          annotations_with_whitespace = if has_annotations
+            begin
+              annotation_start = @finder.annotation_start
+              annotation_end = @finder.annotation_end
+
+              if @file_lines[annotation_start - 1]&.strip&.empty?
+                annotation_start -= 1
+                has_leading_whitespace = true
+              end
+
+              if @file_lines[annotation_end + 1]&.strip&.empty?
+                annotation_end += 1
+                has_trailing_whitespace = true
+              end
+
+              @file_lines[annotation_start..annotation_end].join
+            end
+          else
+            ""
+          end
+
+          # :before or :after when it's set
+          annotation_position = nil
+
+          if has_annotations
+            const_declaration = @file_parser.starts.first
+
+            # If the file does not have any class or module declaration then const_declaration can be nil
+            _const, line_number = const_declaration
+
+            if line_number
+              annotation_position = if @finder.annotation_start < line_number
+                :before
+              else
+                :after
+              end
+            end
+          end
+
+          _result = ParsedFileResult.new(
+            has_annotations: has_annotations,
+            has_skip_string: has_skip_string,
+            annotations_changed: annotations_changed,
+            annotations: annotations,
+            annotations_with_whitespace: annotations_with_whitespace,
+            has_leading_whitespace: has_leading_whitespace,
+            has_trailing_whitespace: has_trailing_whitespace,
+            annotation_position: annotation_position
+          )
+        end
+      end
+    end
+  end
+end

data/lib/annotate_rb/model_annotator/file_parser/parsed_file_result.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module AnnotateRb
+  module ModelAnnotator
+    module FileParser
+      class ParsedFileResult
+        def initialize(
+          has_annotations:,
+          has_skip_string:,
+          annotations_changed:,
+          annotations:,
+          annotations_with_whitespace:,
+          has_leading_whitespace:,
+          has_trailing_whitespace:,
+          annotation_position:
+        )
+          @has_annotations = has_annotations
+          @has_skip_string = has_skip_string
+          @annotations_changed = annotations_changed
+          @annotations = annotations
+          @annotations_with_whitespace = annotations_with_whitespace
+          @has_leading_whitespace = has_leading_whitespace
+          @has_trailing_whitespace = has_trailing_whitespace
+          @annotation_position = annotation_position
+        end
+
+        attr_reader :annotations, :annotation_position
+
+        # Returns annotations with new line before and after if they exist
+        attr_reader :annotations_with_whitespace
+
+        def annotations_changed?
+          @annotations_changed
+        end
+
+        def has_annotations?
+          @has_annotations
+        end
+
+        def has_skip_string?
+          @has_skip_string
+        end
+
+        def has_leading_whitespace?
+          @has_leading_whitespace
+        end
+
+        def has_trailing_whitespace?
+          @has_trailing_whitespace
+        end
+      end
+    end
+  end
+end

data/lib/annotate_rb/model_annotator/file_parser.rb

@@ -3,7 +3,10 @@
 module AnnotateRb
   module ModelAnnotator
     module FileParser
-      autoload :MagicCommentParser, "annotate_rb/model_annotator/file_parser/magic_comment_parser"
+      autoload :AnnotationFinder, "annotate_rb/model_annotator/file_parser/annotation_finder"
+      autoload :CustomParser, "annotate_rb/model_annotator/file_parser/custom_parser"
+      autoload :ParsedFile, "annotate_rb/model_annotator/file_parser/parsed_file"
+      autoload :ParsedFileResult, "annotate_rb/model_annotator/file_parser/parsed_file_result"
     end
   end
 end

data/lib/annotate_rb/model_annotator/model_class_getter.rb

@@ -8,6 +8,13 @@ module AnnotateRb
         # Check for namespaced models in subdirectories as well as models
         # in subdirectories without namespacing.
         def call(file, options)
+          use_zeitwerk = defined?(::Rails) && ::Rails.try(:autoloaders).try(:zeitwerk_enabled?)
+
+          if use_zeitwerk
+            klass = ZeitwerkClassGetter.call(file, options)
+            return klass if klass
+          end
+
           model_path = file.gsub(/\.rb$/, "")
           options[:model_dir].each { |dir| model_path = model_path.gsub(/^#{dir}/, "").gsub(/^\//, "") }
 

data/lib/annotate_rb/model_annotator/model_wrapper.rb

@@ -115,7 +115,16 @@ module AnnotateRb
 
         # Try to search the table without prefix
         table_name_without_prefix = table_name.to_s.sub(@klass.table_name_prefix, "")
-        @klass.connection.indexes(table_name_without_prefix)
+        begin
+          @klass.connection.indexes(table_name_without_prefix)
+        rescue ActiveRecord::StatementInvalid => _e
+          # Mysql2 adapter behaves differently than Sqlite3 and Postgres adapter.
+          # If `table_name_without_prefix` does not exist, Mysql2 will raise,
+          # the other adapters will return an empty array.
+          #
+          # See: https://github.com/rails/rails/issues/51205
+          []
+        end
       end
 
       def with_comments?

data/lib/annotate_rb/model_annotator/related_files_list_builder.rb

@@ -24,10 +24,10 @@ module AnnotateRb
         add_related_scaffold_files if !@options[:exclude_scaffolds]
         add_related_controller_files if !@options[:exclude_controllers]
         add_related_helper_files if !@options[:exclude_helpers]
-        add_related_admin_files if !@options[:active_admin]
-        add_additional_file_patterns if !@options[:additional_file_patterns].present?
+        add_related_admin_files if @options[:active_admin]
+        add_additional_file_patterns if @options[:additional_file_patterns].present?
 
-        @list
+        @list.uniq
       end
 
       private

data/lib/annotate_rb/model_annotator/single_file_annotation_remover.rb

@@ -12,20 +12,18 @@ module AnnotateRb
           return false unless File.exist?(file_name)
           old_content = File.read(file_name)
 
-          file_components = FileComponents.new(old_content, "", options)
-
-          return false if file_components.has_skip_string?
-          # TODO: Uncomment below after tests are fixed
-          # return false if !file_components.has_annotations?
-
-          wrapper_open = if options[:wrapper_open]
-            "# #{options[:wrapper_open]}\n"
-          else
-            ""
+          begin
+            parsed_file = FileParser::ParsedFile.new(old_content, "", options).parse
+          rescue FileParser::AnnotationFinder::MalformedAnnotation => e
+            warn "Unable to process #{file_name}: #{e.message}"
+            warn "\t" + e.backtrace.join("\n\t") if @options[:trace]
+            return false
           end
 
-          generated_pattern = AnnotationPatternGenerator.call(options)
-          updated_file_content = old_content.sub!(/(#{wrapper_open})?#{generated_pattern}/, "")
+          return false if !parsed_file.has_annotations?
+          return false if parsed_file.has_skip_string?
+
+          updated_file_content = old_content.sub(parsed_file.annotations_with_whitespace, "")
 
           File.open(file_name, "wb") { |f| f.puts updated_file_content }
 

data/lib/annotate_rb/model_annotator/single_file_annotator.rb

@@ -25,17 +25,25 @@ module AnnotateRb
           return false unless File.exist?(file_name)
           old_content = File.read(file_name)
 
-          file_components = FileComponents.new(old_content, annotation, options)
+          begin
+            parsed_file = FileParser::ParsedFile.new(old_content, annotation, options).parse
+          rescue FileParser::AnnotationFinder::MalformedAnnotation => e
+            warn "Unable to process #{file_name}: #{e.message}"
+            warn "\t" + e.backtrace.join("\n\t") if @options[:trace]
+            return false
+          end
 
-          return false if file_components.has_skip_string?
-          return false if !file_components.annotations_changed? && !options[:force]
+          return false if parsed_file.has_skip_string?
+          return false if !parsed_file.annotations_changed? && !options[:force]
 
           abort "AnnotateRb error. #{file_name} needs to be updated, but annotaterb was run with `--frozen`." if options[:frozen]
 
-          updated_file_content = if !file_components.has_annotations? || options[:force]
-            AnnotatedFile::Generator.new(file_components, annotation_position, options).generate
+          updated_file_content = if !parsed_file.has_annotations?
+            AnnotatedFile::Generator.new(old_content, annotation, annotation_position, options).generate
+          elsif options[:force]
+            AnnotatedFile::Generator.new(old_content, annotation, annotation_position, options).generate
           else
-            AnnotatedFile::Updater.new(file_components, annotation_position, options).update
+            AnnotatedFile::Updater.new(old_content, annotation, annotation_position, options).update
           end
 
           File.open(file_name, "wb") { |f| f.puts updated_file_content }

data/lib/annotate_rb/model_annotator/zeitwerk_class_getter.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+module AnnotateRb
+  module ModelAnnotator
+    class ZeitwerkClassGetter
+      class << self
+        def call(file, options)
+          new(file, options).call
+        end
+      end
+
+      def initialize(file, options)
+        @file = file
+        @options = options
+      end
+
+      # @return [Constant, nil] Attempts to return the model class constant (e.g. User) defined in the model file
+      #   can return `nil` if the file does not define the constant.
+      def call
+        return unless defined?(::Zeitwerk)
+
+        @absolute_file_path = File.expand_path(@file)
+        loader = ::Rails.autoloaders.main
+
+        if supports_cpath?
+          constant_using_cpath(loader)
+        else
+          constant(loader)
+        end
+      end
+
+      private
+
+      def constant(loader)
+        root_dirs = loader.dirs(namespaces: true) # or `root_dirs = loader.root_dirs` with zeitwerk < 2.6.1
+        expanded_file = @absolute_file_path
+
+        # root_dir: "/home/dummyapp/app/models"
+        root_dir, namespace = root_dirs.find do |dir, _namespace|
+          expanded_file.start_with?(dir)
+        end
+
+        # expanded_file: "/home/dummyapp/app/models/collapsed/example/test_model.rb"
+        # filepath_relative_to_root_dir: "/collapsed/example/test_model.rb"
+        _, filepath_relative_to_root_dir = expanded_file.split(root_dir)
+
+        # Remove leading / and the .rb extension
+        filepath_relative_to_root_dir = filepath_relative_to_root_dir[1..].sub(/\.rb$/, "")
+
+        # once we have the filepath_relative_to_root_dir, we need to see if it
+        # falls within one of our Zeitwerk "collapsed" paths.
+        if loader.collapse.any? { |path| path.include?(root_dir) && file.include?(path.split(root_dir)[1]) }
+          # if the file is within a collapsed path, we then need to, for each
+          # collapsed path, remove the root dir
+          collapsed = loader.collapse.map { |path| path.split(root_dir)[1].sub(/^\//, "") }.to_set
+
+          collapsed.each do |collapse|
+            # next, we split the collapsed directory, e.g. `domain_name/models`, by
+            # slash, and discard the domain_name
+            _, *collapsed_namespace = collapse.split("/")
+
+            # if there are any collapsed namespaces, e.g. `models`, we then remove
+            # that from `filepath_relative_to_root_dir`.
+            #
+            # This would result in:
+            #
+            # previous filepath_relative_to_root_dir: domain_name/models/model_name
+            # new filepath_relative_to_root_dir: domain_name/model_name
+            if collapsed_namespace.any?
+              filepath_relative_to_root_dir.sub!("/#{collapsed_namespace.last}", "")
+            end
+          end
+        end
+
+        camelize = loader.inflector.camelize(filepath_relative_to_root_dir, nil)
+        namespace.const_get(camelize)
+      rescue NameError => e
+        warn e
+        nil
+      end
+
+      def constant_using_cpath(loader)
+        begin
+          constant = loader.cpath_expected_at(@absolute_file_path)
+        rescue ::Zeitwerk::Error => e
+          # Raises when file does not exist
+          warn "Zeitwerk unable to find file #{@file}, error:\n#{e.message}"
+          return
+        end
+
+        begin
+          # This uses ActiveSupport::Inflector.constantize
+          klass = constant.constantize
+        rescue NameError => e
+          warn e
+          return
+        end
+
+        klass
+      end
+
+      def supports_cpath?
+        @supports_cpath ||=
+          begin
+            current_version = ::Gem::Version.new(::Zeitwerk::VERSION)
+            required_version = ::Gem::Version.new("2.6.9")
+
+            current_version >= required_version
+          end
+      end
+    end
+  end
+end

data/lib/annotate_rb/model_annotator.rb

@@ -7,7 +7,6 @@ module AnnotateRb
     autoload :BadModelFileError, "annotate_rb/model_annotator/bad_model_file_error"
     autoload :FileNameResolver, "annotate_rb/model_annotator/file_name_resolver"
     autoload :SingleFileAnnotationRemover, "annotate_rb/model_annotator/single_file_annotation_remover"
-    autoload :AnnotationPatternGenerator, "annotate_rb/model_annotator/annotation_pattern_generator"
     autoload :ModelClassGetter, "annotate_rb/model_annotator/model_class_getter"
     autoload :ModelFilesGetter, "annotate_rb/model_annotator/model_files_getter"
     autoload :SingleFileAnnotator, "annotate_rb/model_annotator/single_file_annotator"
@@ -22,10 +21,10 @@ module AnnotateRb
     autoload :SingleFileRemoveAnnotationInstruction, "annotate_rb/model_annotator/single_file_remove_annotation_instruction"
     autoload :AnnotationDiffGenerator, "annotate_rb/model_annotator/annotation_diff_generator"
     autoload :AnnotationDiff, "annotate_rb/model_annotator/annotation_diff"
-    autoload :FileComponents, "annotate_rb/model_annotator/file_components"
     autoload :ProjectAnnotator, "annotate_rb/model_annotator/project_annotator"
     autoload :ProjectAnnotationRemover, "annotate_rb/model_annotator/project_annotation_remover"
     autoload :AnnotatedFile, "annotate_rb/model_annotator/annotated_file"
     autoload :FileParser, "annotate_rb/model_annotator/file_parser"
+    autoload :ZeitwerkClassGetter, "annotate_rb/model_annotator/zeitwerk_class_getter"
   end
 end

data/lib/annotate_rb/tasks/annotate_models_migrate.rake

@@ -6,6 +6,11 @@
 
 # Migration tasks are tasks that we'll "hook" into
 migration_tasks = %w[db:migrate db:migrate:up db:migrate:down db:migrate:reset db:migrate:redo db:rollback]
+
+# Support for data_migrate gem (https://github.com/ilyakatz/data-migrate)
+migration_tasks_with_data = migration_tasks.map { |task| "#{task}:with_data" }
+migration_tasks += migration_tasks_with_data
+
 if defined?(Rails::Application) && Rails.version.split(".").first.to_i >= 6
   require "active_record"
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: annotaterb
 version: !ruby/object:Gem::Version
-  version: 4.5.0
+  version: 4.6.0
 platform: ruby
 authors:
 - Andrew W. Lee
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2024-02-08 00:00:00.000000000 Z
+date: 2024-02-27 00:00:00.000000000 Z
 dependencies: []
 description: Annotates Rails/ActiveRecord Models, routes, fixtures, and others based
   on the database schema.
@@ -44,7 +44,6 @@ files:
 - lib/annotate_rb/model_annotator/annotation_decider.rb
 - lib/annotate_rb/model_annotator/annotation_diff.rb
 - lib/annotate_rb/model_annotator/annotation_diff_generator.rb
-- lib/annotate_rb/model_annotator/annotation_pattern_generator.rb
 - lib/annotate_rb/model_annotator/annotator.rb
 - lib/annotate_rb/model_annotator/bad_model_file_error.rb
 - lib/annotate_rb/model_annotator/column_annotation.rb
@@ -53,10 +52,12 @@ files:
 - lib/annotate_rb/model_annotator/column_annotation/column_wrapper.rb
 - lib/annotate_rb/model_annotator/column_annotation/default_value_builder.rb
 - lib/annotate_rb/model_annotator/column_annotation/type_builder.rb
-- lib/annotate_rb/model_annotator/file_components.rb
 - lib/annotate_rb/model_annotator/file_name_resolver.rb
 - lib/annotate_rb/model_annotator/file_parser.rb
-- lib/annotate_rb/model_annotator/file_parser/magic_comment_parser.rb
+- lib/annotate_rb/model_annotator/file_parser/annotation_finder.rb
+- lib/annotate_rb/model_annotator/file_parser/custom_parser.rb
+- lib/annotate_rb/model_annotator/file_parser/parsed_file.rb
+- lib/annotate_rb/model_annotator/file_parser/parsed_file_result.rb
 - lib/annotate_rb/model_annotator/foreign_key_annotation.rb
 - lib/annotate_rb/model_annotator/foreign_key_annotation/annotation_builder.rb
 - lib/annotate_rb/model_annotator/index_annotation.rb
@@ -72,6 +73,7 @@ files:
 - lib/annotate_rb/model_annotator/single_file_annotator.rb
 - lib/annotate_rb/model_annotator/single_file_annotator_instruction.rb
 - lib/annotate_rb/model_annotator/single_file_remove_annotation_instruction.rb
+- lib/annotate_rb/model_annotator/zeitwerk_class_getter.rb
 - lib/annotate_rb/options.rb
 - lib/annotate_rb/parser.rb
 - lib/annotate_rb/rake_bootstrapper.rb
@@ -116,7 +118,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.33
+rubygems_version: 3.5.6
 signing_key:
 specification_version: 4
 summary: A gem for generating annotations for Rails projects.

data/lib/annotate_rb/model_annotator/annotation_pattern_generator.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-module AnnotateRb
-  module ModelAnnotator
-    class AnnotationPatternGenerator
-      COMPAT_PREFIX = "== Schema Info"
-      COMPAT_PREFIX_MD = "## Schema Info"
-
-      class << self
-        def call(options)
-          if options[:wrapper_open]
-            return /(?:^(\n|\r\n)?# (?:#{options[:wrapper_open]}).*(\n|\r\n)?# (?:#{COMPAT_PREFIX}|#{COMPAT_PREFIX_MD}).*?(\n|\r\n)(#.*(\n|\r\n))*(\n|\r\n)*)|^(\n|\r\n)?# (?:#{COMPAT_PREFIX}|#{COMPAT_PREFIX_MD}).*?(\n|\r\n)(#.*(\n|\r\n))*(\n|\r\n)*/
-          end
-          /^(\n|\r\n)?# (?:#{COMPAT_PREFIX}|#{COMPAT_PREFIX_MD}).*?(\n|\r\n)(#.*(\n|\r\n))*(\n|\r\n)*/o
-        end
-      end
-    end
-  end
-end

data/lib/annotate_rb/model_annotator/file_components.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module AnnotateRb
-  module ModelAnnotator
-    class FileComponents
-      SKIP_ANNOTATION_STRING = "# -*- SkipSchemaAnnotations"
-      SOME_PATTERN = /\A(?<start>\s*).*?\n(?<end>\s*)\z/m # Unsure what this pattern is
-
-      attr_reader :new_annotations
-
-      def initialize(file_content, new_annotations, options)
-        @file_content = file_content
-        @diff = AnnotationDiffGenerator.new(file_content, new_annotations).generate
-        @options = options
-        @annotation_pattern = AnnotationPatternGenerator.call(options)
-        @new_annotations = new_annotations
-      end
-
-      def current_file_content
-        @file_content
-      end
-
-      # TODO: Rename method once it's clear what this actually does
-      def space_before_annotation
-        return @space_before_annotation if defined?(@space_before_annotation)
-
-        match = current_annotations.match(SOME_PATTERN)
-        @space_before_annotation = if match
-          match[:start]
-        end
-      end
-
-      # TODO: Rename method once it's clear what this actually does
-      def space_after_annotation
-        return @space_after_annotation if defined?(@space_after_annotation)
-
-        match = current_annotations.match(SOME_PATTERN)
-        @space_after_annotation = if match
-          match[:end]
-        end
-      end
-
-      def pure_file_content
-        @pure_file_content ||=
-          begin
-            content_without_magic_comments = @file_content.gsub(FileParser::MagicCommentParser::MAGIC_COMMENTS_REGEX, "")
-            content_without_annotations = content_without_magic_comments.sub(@annotation_pattern, "")
-
-            content_without_annotations
-          end
-      end
-
-      def magic_comments
-        @magic_comments ||= FileParser::MagicCommentParser.call(@file_content)
-      end
-
-      def has_skip_string?
-        @has_skip_string ||= @file_content.include?(SKIP_ANNOTATION_STRING)
-      end
-
-      def has_annotations?
-        @has_annotations ||= @diff.current_columns.present?
-      end
-
-      def annotations_changed?
-        @has_annotations_changed ||= @diff.changed?
-      end
-
-      def current_annotations
-        @current_annotations ||=
-          if has_annotations?
-            # `#has_annotations?` uses a different regex pattern than the one in `@annotation_pattern`,
-            # this could lead to unexpected behavior
-            @file_content.match(@annotation_pattern).to_s
-          else
-            ""
-          end
-      end
-    end
-  end
-end

data/lib/annotate_rb/model_annotator/file_parser/magic_comment_parser.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module AnnotateRb
-  module ModelAnnotator
-    module FileParser
-      # Extracts magic comments strings and returns them
-      class MagicCommentParser
-        MAGIC_COMMENTS = [
-          HASH_ENCODING = /(^#\s*encoding:.*(?:\n|r\n))/,
-          HASH_CODING = /(^# coding:.*(?:\n|\r\n))/,
-          HASH_FROZEN_STRING = /(^#\s*frozen_string_literal:.+(?:\n|\r\n))/,
-          STAR_ENCODING = /(^# -\*- encoding\s?:.*(?:\n|\r\n))/,
-          STAR_CODING = /(^# -\*- coding:.*(?:\n|\r\n))/,
-          STAR_FROZEN_STRING = /(^# -\*- frozen_string_literal\s*:.+-\*-(?:\n|\r\n))/,
-          SORBET_TYPED_STRING = /(^#\s*typed:.*(?:\n|r\n))/.freeze
-        ].freeze
-
-        MAGIC_COMMENTS_REGEX = Regexp.union(*MAGIC_COMMENTS).freeze
-
-        class << self
-          def call(content)
-            magic_comments = content.scan(MAGIC_COMMENTS_REGEX).flatten.compact
-
-            if magic_comments.any?
-              magic_comments.join
-            else
-              ""
-            end
-          end
-        end
-      end
-    end
-  end
-end