class Rails::SourceAnnotationExtractor

of the line (or closing ERB comment tag) is considered to be their text.
start with the tag optionally followed by a colon. Everything up to the end
Annotations are looked for in comments and modulus whitespace they have to
the filename is not stored.
represent the line where the annotation lives, its tag, and its text. Note
Annotation objects are triplets :line, :tag, :text that
Implements the logic behind Rails::Command::NotesCommand. See rails notes --help for usage information.

def self.enumerate(tag = nil, options = {})

This class method is the single entry point for the rails notes command.

See SourceAnnotationExtractor#find_in for a list of file extensions that will be taken into account.

If +options+ has a :tag flag, it will be passed to each annotation's +to_s+.

Rails::SourceAnnotationExtractor.enumerate 'TODO|FIXME', dirs: %w(app lib), tag: true

Specific directories can be explicitly set using the :dirs key in +options+.

If +tag+ is nil, annotations with either default or registered tags are printed.

+config+, +db+, +lib+, and +test+ (recursively).
Prints all annotations with tag +tag+ under the root directories +app+, 
def self.enumerate(tag = nil, options = {})
  tag ||= Annotation.tags.join("|")
  extractor = new(tag)
  dirs = options.delete(:dirs) || Annotation.directories
  extractor.display(extractor.find(dirs), options)
end

def display(results, options = {})

The +options+ hash is passed to each annotation's +to_s+.
Prints the mapping from filenames to annotations in +results+ ordered by filename. 
def display(results, options = {})
  options[:indent] = results.flat_map { |f, a| a.map(&:line) }.max.to_s.size
  results.keys.sort.each do |file|
    puts "#{file}:"
    results[file].each do |note|
      puts "  * #{note.to_s(options)}"
    end
    puts
  end
end

def find(dirs)

with their annotations.
Returns a hash that maps filenames under +dirs+ (recursively) to arrays 
def find(dirs)
  dirs.inject({}) { |h, dir| h.update(find_in(dir)) }
end

def find_in(dir)

taken into account. Only files with annotations are included.
Rails::SourceAnnotationExtractor::Annotation.extensions are
with their annotations. Files with extensions registered in
Returns a hash that maps filenames under +dir+ (recursively) to arrays 
def find_in(dir)
  results = {}
  Dir.glob("#{dir}/*") do |item|
    next if File.basename(item).start_with?(".")
    if File.directory?(item)
      results.update(find_in(item))
    else
      extension = Annotation.extensions.detect do |regexp, _block|
        regexp.match(item)
      end
      if extension
        pattern = extension.last.call(tag)
        # In case a user-defined pattern returns nothing for the given set
        # of tags, we exit early.
        next unless pattern
        # If a user-defined pattern returns a regular expression, we will
        # wrap it in a PatternExtractor to keep the same API.
        pattern = PatternExtractor.new(pattern) if pattern.is_a?(Regexp)
        annotations = pattern.annotations(item)
        results.update(item => annotations) if annotations.any?
      end
    end
  end
  results
end

def initialize(tag) 

def initialize(tag)
  @tag = tag
end