class 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
and friends. See rake -T notes and railties/lib/tasks/annotations.rake.
rake notes:optimize
rake notes
Implements the logic behind the rake tasks for annotations like

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

This class method is the single entry point for the rake tasks.

See #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+.

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

Directories may also be explicitly set using the :dirs key in +options+.

ENV['SOURCE_ANNOTATION_DIRECTORIES'].
Additional directories may be added using a comma-delimited list set using

+config+, +db+, +lib+, and +test+ (recursively).
Prints all annotations with tag +tag+ under the root directories +app+, 
def self.enumerate(tag, options={})
  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.map { |f, a| a.map(&:line) }.flatten.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 extract_annotations_from(file, pattern)

Otherwise it returns an empty hash.
a hash with a single entry that maps +file+ to an array of its annotations.
If +file+ is the filename of a file that contains annotations this method returns 
def extract_annotations_from(file, pattern)
  lineno = 0
  result = File.readlines(file).inject([]) do |list, line|
    lineno += 1
    next list unless line =~ pattern
    list << Annotation.new(lineno, $1, $2)
  end
  result.empty? ? {} : { file => result }
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)

are taken into account.
+.scss+, +.js+, +.coffee+, and +.rake+
with extension +.builder+, +.rb+, +.erb+, +.haml+, +.slim+, +.css+,
with their annotations. Only files with annotations are included. Files
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)[0] == ?.
    if File.directory?(item)
      results.update(find_in(item))
    else
      pattern =
          case item
          when /\.(builder|rb|coffee|rake)$/
            /#\s*(#{tag}):?\s*(.*)$/
          when /\.(css|scss|js)$/
            /\/\/\s*(#{tag}):?\s*(.*)$/
          when /\.erb$/
            /<%\s*#\s*(#{tag}):?\s*(.*?)\s*%>/
          when /\.haml$/
            /-\s*#\s*(#{tag}):?\s*(.*)$/
          when /\.slim$/
            /\/\s*\s*(#{tag}):?\s*(.*)$/
          else nil
          end
      results.update(extract_annotations_from(item, pattern)) if pattern
    end
  end
  results
end

def initialize(tag) 

def initialize(tag)
  @tag = tag
end