Class: Rails::SourceAnnotationExtractor

Inherits:
Object
  • Object
show all
Defined in:
railties/lib/rails/source_annotation_extractor.rb

Overview

Implements the logic behind Rails::Command::NotesCommand. See rails notes --help for usage information.

Annotation objects are triplets :line, :tag, :text that represent the line where the annotation lives, its tag, and its text. Note the filename is not stored.

Annotations are looked for in comments and modulus whitespace they have to start with the tag optionally followed by a colon. Everything up to the end of the line (or closing ERB comment tag) is considered to be their text.

Defined Under Namespace

Classes: Annotation, ParserExtractor, PatternExtractor

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(tag) ⇒ SourceAnnotationExtractor

Returns a new instance of SourceAnnotationExtractor.



130
131
132
 
# File 'railties/lib/rails/source_annotation_extractor.rb', line 130

def initialize(tag)
  @tag = tag
end

Instance Attribute Details

#tag ⇒ Object (readonly)

Returns the value of attribute tag.



128
129
130
 
# File 'railties/lib/rails/source_annotation_extractor.rb', line 128

def tag
  @tag
end

Class Method Details

.enumerate(tag = nil, options = {}) ⇒ Object

Prints all annotations with tag tag under the root directories app, config, db, lib, and test (recursively).

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

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

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

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

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

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



121
122
123
124
125
126
 
# File 'railties/lib/rails/source_annotation_extractor.rb', line 121

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

Instance Method Details

#display(results, options = {}) ⇒ Object

Prints the mapping from filenames to annotations in results ordered by filename. The options hash is passed to each annotation’s to_s.



179
180
181
182
183
184
185
186
187
188
 
# File 'railties/lib/rails/source_annotation_extractor.rb', line 179

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).strip}"
    end
    puts
  end
end

#find(dirs) ⇒ Object

Returns a hash that maps filenames under dirs (recursively) to arrays with their annotations.



136
137
138
 
# File 'railties/lib/rails/source_annotation_extractor.rb', line 136

def find(dirs)
  dirs.inject({}) { |h, dir| h.update(find_in(dir)) }
end

#find_in(dir) ⇒ Object

Returns a hash that maps filenames under dir (recursively) to arrays with their annotations. Files with extensions registered in Rails::SourceAnnotationExtractor::Annotation.extensions are taken into account. Only files with annotations are included.



144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
 
# File 'railties/lib/rails/source_annotation_extractor.rb', line 144

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