\d+))?$}
12 | }
13 | }
14 |
15 | before { allow(klass).to receive(:name).and_return('UnknownTag') }
16 |
17 | context 'when matches' do
18 | let(:input) { 'Unknown tag @wrong in file `input/lot_of_errors.rb` near line 15' }
19 |
20 | its(:to_h) {
21 | is_expected.to eq(type: 'UnknownTag', message: 'Unknown tag @wrong', tag: 'wrong', file: 'input/lot_of_errors.rb', line: 15)
22 | }
23 | end
24 |
25 | context 'when partial match' do
26 | let(:input) { 'Unknown tag @wrong' }
27 |
28 | its(:to_h) {
29 | is_expected.to eq(type: 'UnknownTag', message: 'Unknown tag @wrong', tag: 'wrong', file: nil, line: 1)
30 | }
31 | end
32 |
33 | context 'with parsing context' do
34 | subject { klass.try_parse(input, file: 'input/lot_of_errors.rb') }
35 |
36 | let(:input) { 'Unknown tag @wrong' }
37 |
38 | its(:to_h) {
39 | is_expected.to eq(type: 'UnknownTag', message: 'Unknown tag @wrong', tag: 'wrong', file: 'input/lot_of_errors.rb', line: 1)
40 | }
41 | end
42 |
43 | context 'when not matches' do
44 | let(:input) { '@param tag has unknown parameter name: arg3' }
45 |
46 | it { is_expected.to be_nil }
47 | end
48 |
49 | context 'with search_up' do
50 | let(:input) { 'Unknown tag @wrong in file `lot_of_errors.rb` near line 5' }
51 |
52 | before {
53 | klass.search_up '@%{tag}(\W|$)'
54 | File.write 'lot_of_errors.rb', %{
55 | # @wrong
56 | #
57 | # Something else.
58 | def foo
59 | end
60 | }
61 | }
62 |
63 | its(:to_h) {
64 | is_expected.to include(file: 'lot_of_errors.rb', line: 2)
65 | }
66 | end
67 | end
68 |
69 | describe '#to_s' do
70 | context 'by default' do
71 | subject { klass.new(message: 'Unknown tag @wrong', tag: 'wrong', file: 'lot_of_errors.rb', line: 2) }
72 |
73 | let(:klass) {
74 | Class.new(described_class)
75 | }
76 |
77 | before { allow(klass).to receive(:name).and_return('UnknownTag') }
78 |
79 | its(:to_s) { is_expected.to eq 'lot_of_errors.rb:2: [UnknownTag] Unknown tag @wrong' }
80 | end
81 | end
82 | end
83 |
--------------------------------------------------------------------------------
/Gemfile.lock:
--------------------------------------------------------------------------------
1 | PATH
2 | remote: .
3 | specs:
4 | yard-junk (0.0.10)
5 | backports (>= 3.18)
6 | ostruct
7 | rainbow
8 | yard
9 |
10 | GEM
11 | remote: https://rubygems.org/
12 | specs:
13 | ast (2.4.2)
14 | backports (3.25.0)
15 | diff-lcs (1.5.1)
16 | docile (1.4.1)
17 | fakefs (2.5.0)
18 | io-console (0.7.2)
19 | io-console (0.7.2-java)
20 | irb (1.14.0)
21 | rdoc (>= 4.0.0)
22 | reline (>= 0.4.2)
23 | jar-dependencies (0.4.1)
24 | json (2.7.2)
25 | json (2.7.2-java)
26 | kramdown (2.4.0)
27 | rexml
28 | language_server-protocol (3.17.0.3)
29 | ostruct (0.6.0)
30 | parallel (1.26.3)
31 | parser (3.3.5.0)
32 | ast (~> 2.4.1)
33 | racc
34 | psych (5.1.2)
35 | stringio
36 | psych (5.1.2-java)
37 | jar-dependencies (>= 0.1.7)
38 | racc (1.8.1)
39 | racc (1.8.1-java)
40 | rainbow (3.1.1)
41 | rake (13.2.1)
42 | rdoc (6.7.0)
43 | psych (>= 4.0.0)
44 | regexp_parser (2.9.2)
45 | reline (0.5.10)
46 | io-console (~> 0.5)
47 | rexml (3.3.7)
48 | rspec (3.13.0)
49 | rspec-core (~> 3.13.0)
50 | rspec-expectations (~> 3.13.0)
51 | rspec-mocks (~> 3.13.0)
52 | rspec-core (3.13.1)
53 | rspec-support (~> 3.13.0)
54 | rspec-expectations (3.13.2)
55 | diff-lcs (>= 1.2.0, < 2.0)
56 | rspec-support (~> 3.13.0)
57 | rspec-its (1.3.0)
58 | rspec-core (>= 3.0.0)
59 | rspec-expectations (>= 3.0.0)
60 | rspec-mocks (3.13.1)
61 | diff-lcs (>= 1.2.0, < 2.0)
62 | rspec-support (~> 3.13.0)
63 | rspec-support (3.13.1)
64 | rubocop (1.66.1)
65 | json (~> 2.3)
66 | language_server-protocol (>= 3.17.0)
67 | parallel (~> 1.10)
68 | parser (>= 3.3.0.2)
69 | rainbow (>= 2.2.2, < 4.0)
70 | regexp_parser (>= 2.4, < 3.0)
71 | rubocop-ast (>= 1.32.2, < 2.0)
72 | ruby-progressbar (~> 1.7)
73 | unicode-display_width (>= 2.4.0, < 3.0)
74 | rubocop-ast (1.32.3)
75 | parser (>= 3.3.1.0)
76 | rubocop-rspec (3.0.4)
77 | rubocop (~> 1.61)
78 | ruby-progressbar (1.13.0)
79 | ruby2_keywords (0.0.5)
80 | rubygems-tasks (0.2.6)
81 | irb (~> 1.0)
82 | rake (>= 10.0.0)
83 | saharspec (0.0.10)
84 | ruby2_keywords
85 | simplecov (0.22.0)
86 | docile (~> 1.1)
87 | simplecov-html (~> 0.11)
88 | simplecov_json_formatter (~> 0.1)
89 | simplecov-html (0.12.3)
90 | simplecov_json_formatter (0.1.4)
91 | stringio (3.1.1)
92 | unicode-display_width (2.5.0)
93 | yard (0.9.37)
94 |
95 | PLATFORMS
96 | java
97 | ruby
98 |
99 | DEPENDENCIES
100 | fakefs
101 | kramdown
102 | rake
103 | rspec (>= 3)
104 | rspec-its (~> 1)
105 | rubocop
106 | rubocop-rspec
107 | rubygems-tasks
108 | saharspec
109 | simplecov (~> 0.9)
110 | yard
111 | yard-junk!
112 |
113 | BUNDLED WITH
114 | 2.4.22
115 |
--------------------------------------------------------------------------------
/lib/yard-junk/janitor/html_reporter.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | require 'erb'
4 | require 'ostruct'
5 |
6 | module YardJunk
7 | class Janitor
8 | # Reporter that just outputs everything in HTML format. Useful
9 | # for usage with Jenkins. See {BaseReporter} for details about reporters.
10 | #
11 | class HtmlReporter < BaseReporter
12 | HEADER = <<-HTML
13 |
14 |
15 |
16 |
17 | YARD-Junk Report
18 |
45 |
46 |
47 | YARD Validation Report
48 | HTML
49 |
50 | FOOTER = <<-HTML
51 |
52 |
53 | HTML
54 |
55 | SECTION = <<-HTML
56 |
57 | <%= title %>
58 | (<%= explanation %>)
59 |
60 | HTML
61 |
62 | ROW = <<-HTML
63 | <%= file %>:<%= line %>: <%= message %>
64 | HTML
65 |
66 | STATS = <<-HTML
67 |
68 | <%= errors %> failures,
69 | <%= problems %> problems
70 | (ready in <%= duration %>)
71 |
72 | HTML
73 |
74 | Helper = Class.new(OpenStruct) do
75 | def the_binding
76 | binding
77 | end
78 | end
79 |
80 | attr_reader :html
81 |
82 | def initialize(*)
83 | super
84 | @html = HEADER.dup
85 | end
86 |
87 | def finalize
88 | @html << FOOTER
89 | @io.puts(@html)
90 | end
91 |
92 | private
93 |
94 | def _stats(**stat)
95 | render(STATS, **stat)
96 | end
97 |
98 | def header(title, explanation)
99 | render(SECTION, title: title, explanation: explanation)
100 | end
101 |
102 | def row(message)
103 | render(ROW, **message.to_h)
104 | end
105 |
106 | def render(template, values)
107 | html <<
108 | ERB.new(template)
109 | .result(Helper.new(values).the_binding)
110 | end
111 | end
112 | end
113 | end
114 |
--------------------------------------------------------------------------------
/spec/yard-junk/logger_spec.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | RSpec.describe YardJunk::Logger do
4 | subject(:logger) { described_class.instance }
5 |
6 | before {
7 | logger.clear
8 | logger.format = nil
9 | }
10 |
11 | describe '#register' do
12 | before { logger.register('Unknown tag @wrong in file `input/lot_of_errors.rb` near line 26') }
13 |
14 | its(:'messages.last') {
15 | is_expected
16 | .to be_a(described_class::Message)
17 | .and have_attributes(message: 'Unknown tag @wrong', extra: {tag: '@wrong'}, file: 'input/lot_of_errors.rb', line: 26)
18 | }
19 | end
20 |
21 | describe '#notify' do
22 | context 'on parsing start' do
23 | before {
24 | logger.notify('Parsing foo/bar.rb')
25 | logger.register('Unknown tag @wrong')
26 | }
27 |
28 | its(:'messages.last') { is_expected.to have_attributes(file: 'foo/bar.rb') }
29 | end
30 |
31 | context 'on parsing end' do
32 | before {
33 | logger.notify('Parsing foo/bar.rb')
34 | logger.notify('Generating asset js/jquery.js')
35 | logger.register('Unknown tag @wrong')
36 | }
37 |
38 | its(:'messages.last') { is_expected.to have_attributes(file: nil) }
39 | end
40 | end
41 |
42 | describe '#format=' do
43 | subject { logger.register('Unknown tag @wrong in file `input/lot_of_errors.rb` near line 26') }
44 |
45 | before { logger.clear } # set format to default
46 |
47 | context 'by default' do
48 | its_block { is_expected.to output("input/lot_of_errors.rb:26: [UnknownTag] Unknown tag @wrong\n").to_stdout }
49 | end
50 |
51 | context 'non-empty format' do
52 | before { logger.format = '%{message} (%{file}:%{line})' }
53 |
54 | its_block { is_expected.to output("Unknown tag @wrong (input/lot_of_errors.rb:26)\n").to_stdout }
55 | end
56 |
57 | context 'empty format' do
58 | before { logger.format = nil }
59 |
60 | its_block { is_expected.not_to output.to_stdout }
61 | end
62 | end
63 |
64 | describe '#ignore=' do
65 | subject {
66 | logger.register('Unknown tag @wrong in file `input/lot_of_errors.rb` near line 26')
67 | logger.register(%{in YARD::Handlers::Ruby::AttributeHandler: Undocumentable OPTIONS
68 | in file 'input/lot_of_errors.rb':38:
69 |
70 | 38: attr_reader *OPTIONS})
71 | }
72 |
73 | before { logger.clear } # Set output format to default
74 |
75 | context 'by default' do
76 | its_block { is_expected.to output("input/lot_of_errors.rb:26: [UnknownTag] Unknown tag @wrong\n").to_stdout }
77 | end
78 |
79 | context 'set ignores' do
80 | before { logger.ignore = 'UnknownTag' }
81 |
82 | its_block { is_expected.to output("input/lot_of_errors.rb:38: [Undocumentable] Undocumentable OPTIONS: `attr_reader *OPTIONS`\n").to_stdout }
83 | end
84 |
85 | context 'ignore nothing' do
86 | before { logger.ignore = nil }
87 |
88 | its_block { is_expected.to output("input/lot_of_errors.rb:26: [UnknownTag] Unknown tag @wrong\ninput/lot_of_errors.rb:38: [Undocumentable] Undocumentable OPTIONS: `attr_reader *OPTIONS`\n").to_stdout }
89 | end
90 |
91 | context 'set wrong ignores' do
92 | subject { logger.ignore = 'Unknown Tag' }
93 |
94 | its_block { is_expected.to raise_error(ArgumentError, 'Unrecognized message type to ignore: Unknown Tag') }
95 | end
96 | end
97 | end
98 |
--------------------------------------------------------------------------------
/lib/yard-junk/janitor/resolver.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | module YardJunk
4 | class Janitor
5 | class Resolver
6 | include YARD::Templates::Helpers::HtmlHelper
7 | include YARD::Templates::Helpers::MarkupHelper
8 |
9 | # This one is copied from real YARD output
10 | OBJECT_MESSAGE_PATTERN = "In file `%{file}':%{line}: " \
11 | 'Cannot resolve link to %{name} from text: %{link}'
12 |
13 | # ...while this one is totally invented, YARD doesn't check file existance at all
14 | FILE_MESSAGE_PATTERN = "In file `%{file}':%{line}: File '%{name}' does not exist: %{link}"
15 |
16 | def self.resolve_all(yard_options)
17 | YARD::Registry.all.map(&:base_docstring).each { |ds| new(ds, yard_options).resolve }
18 | yard_options.files.each { |file| new(file, yard_options).resolve }
19 | end
20 |
21 | def initialize(object, yard_options)
22 | @options = yard_options
23 | case object
24 | when YARD::CodeObjects::ExtraFileObject
25 | init_file(object)
26 | when YARD::Docstring
27 | init_docstring(object)
28 | else
29 | fail "Unknown object to resolve #{object.class}"
30 | end
31 | end
32 |
33 | def resolve
34 | markup_meth = "html_markup_#{markup}"
35 | return unless respond_to?(markup_meth)
36 |
37 | send(markup_meth, @string)
38 | .gsub(%r{<(code|tt|pre)[^>]*>(.*?)}im, '')
39 | .scan(/{[^}]+}/).flatten
40 | .map(&CGI.method(:unescapeHTML))
41 | .each(&method(:try_resolve))
42 | end
43 |
44 | private
45 |
46 | def init_file(file)
47 | @string = file.contents
48 | @file = file.filename
49 | @line = 1
50 | @markup = markup_for_file(file.contents, file.filename)
51 | end
52 |
53 | def init_docstring(docstring)
54 | @string = docstring
55 | @root_object = docstring.object
56 | @file = @root_object.file
57 | @line = @root_object.line
58 | @markup = options.markup
59 | end
60 |
61 | attr_reader :options, :file, :line, :markup
62 |
63 | def try_resolve(link)
64 | name, _comment = link.tr('{}', '').split(/\s+/, 2)
65 |
66 | # See YARD::Templates::Helpers::BaseHelper#linkify for the source of patterns
67 | # TODO: there is also {include:}, {include:file:} and {render:} syntaxes, but I've never seen
68 | # a project using them. /shrug
69 | case name
70 | when %r{://}, /^mailto:/ # that's pattern YARD uses
71 | # do nothing, assume it is correct
72 | when /^file:(\S+?)(?:#(\S+))?$/
73 | resolve_file(Regexp.last_match[1], link)
74 | else
75 | resolve_code_object(name, link)
76 | end
77 | end
78 |
79 | def resolve_file(name, link)
80 | return if options.files.any? { |f| f.name == name || f.filename == name }
81 |
82 | Logger.instance.register(
83 | FILE_MESSAGE_PATTERN % {file: file, line: line, name: name, link: link}
84 | )
85 | end
86 |
87 | def resolve_code_object(name, link)
88 | resolved = YARD::Registry.resolve(@root_object, name, true, true)
89 | return unless resolved.is_a?(YARD::CodeObjects::Proxy)
90 |
91 | Logger.instance.register(
92 | OBJECT_MESSAGE_PATTERN % {file: file, line: line, name: name, link: link}
93 | )
94 | end
95 |
96 | # Used by HtmlHelper for RDoc
97 | def object
98 | @string.object if @string.is_a?(YARD::Docstring)
99 | end
100 |
101 | # Used by HtmlHelper
102 | def serializer
103 | nil
104 | end
105 | end
106 | end
107 | end
108 |
--------------------------------------------------------------------------------
/lib/yard-junk/janitor.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | require 'benchmark'
4 | require 'backports/2.3.0/enumerable/grep_v'
5 | require 'backports/2.6.0/array/to_h'
6 |
7 | module YardJunk
8 | class Janitor
9 | def initialize(mode: :full, pathes: nil)
10 | @mode = mode
11 | @files = expand_pathes(pathes)
12 | end
13 |
14 | def run(*opts)
15 | YARD::Registry.clear # Somehow loads all Ruby stdlib classes before Rake task started...
16 | Logger.instance.format = nil # Nothing shouuld be printed
17 |
18 | puts "Running YardJunk janitor (version #{YardJunk::VERSION})...\n\n"
19 |
20 | @duration = Benchmark.realtime do
21 | command = YARD::CLI::Yardoc.new
22 | command.run(*prepare_options(opts))
23 | Resolver.resolve_all(command.options) unless mode == :sanity
24 | end
25 |
26 | self
27 | end
28 |
29 | def stats
30 | {
31 | errors: errors.count,
32 | problems: problems.count,
33 | duration: @duration || 0
34 | }
35 | end
36 |
37 | def report(*args, **opts)
38 | guess_reporters(*args, **opts).each do |reporter|
39 | reporter.section('Errors', 'severe code or formatting problems', errors)
40 | reporter.section('Problems', 'mistyped tags or other typos in documentation', problems)
41 |
42 | reporter.stats(**stats)
43 | reporter.finalize
44 | end
45 |
46 | exit_code
47 | end
48 |
49 | def exit_code
50 | case
51 | when !errors.empty? then 2
52 | when !problems.empty? then 1
53 | else 0
54 | end
55 | end
56 |
57 | private
58 |
59 | attr_reader :mode, :files, :yardopts
60 |
61 | BASE_OPTS = %w[--no-save --no-progress --no-stats --no-output --no-cache].freeze
62 |
63 | def prepare_options(opts)
64 | case
65 | when mode == :full || mode == :sanity && files.nil?
66 | [*BASE_OPTS, *opts]
67 | when mode == :sanity
68 | # TODO: specs
69 | [*BASE_OPTS, '--no-yardopts', *yardopts_with_files(files)]
70 | else
71 | fail ArgumentError, "Undefined mode: #{mode.inspect}"
72 | end
73 | end
74 |
75 | def yardopts_with_files(files)
76 | # Use all options from .yardopts file, but replace file lists
77 | YardOptions.new.remove_option('--files').set_files(*files)
78 | end
79 |
80 | def messages
81 | # FIXME: dropping Undocumentable here is not DRY
82 | @messages ||= YardJunk::Logger
83 | .instance
84 | .messages
85 | .grep_v(Logger::Undocumentable)
86 | .select { |m| !files || !m.file || files.include?(File.expand_path(m.file)) }
87 | end
88 |
89 | def errors
90 | messages.select(&:error?)
91 | end
92 |
93 | def problems
94 | messages.select(&:warn?)
95 | end
96 |
97 | def expand_pathes(pathes)
98 | return unless pathes
99 |
100 | Array(pathes)
101 | .map { |path| File.directory?(path) ? File.join(path, '**', '*.*') : path }
102 | .flat_map(&Dir.method(:[]))
103 | .map(&File.method(:expand_path))
104 | end
105 |
106 | # TODO: specs for the logic
107 | def guess_reporters(*symbols, **symbols_with_args)
108 | symbols
109 | .to_h { |sym| [sym, nil] }.merge(symbols_with_args)
110 | .map { |sym, args| ["#{sym.to_s.capitalize}Reporter", args] }
111 | .each { |name,|
112 | Janitor.const_defined?(name) or fail(ArgumentError, "Reporter #{name} not found")
113 | }
114 | .map { |name, args| Janitor.const_get(name).new(*args) }
115 | end
116 | end
117 | end
118 |
119 | require_relative 'janitor/base_reporter'
120 | require_relative 'janitor/text_reporter'
121 | require_relative 'janitor/html_reporter'
122 | require_relative 'janitor/resolver'
123 | require_relative 'janitor/yard_options'
124 |
--------------------------------------------------------------------------------
/spec/yard-junk/janitor/resolver_spec.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | RSpec.describe YardJunk::Janitor::Resolver do
4 | context 'escaped HTML' do
5 | subject { YardJunk::Logger.instance.messages }
6 |
7 | let(:fake_options) { OpenStruct.new(options.merge(markup: markup)) }
8 | let(:markup) { :markdown }
9 | let(:options) { {files: [readme]} }
10 | let(:readme) {
11 | # Not an instance_double, because resolver checks object class
12 | YARD::CodeObjects::ExtraFileObject.new('README.md', readme_contents).tap do |f|
13 | allow(f).to receive_messages(name: 'README', filename: 'README.md')
14 | end
15 | }
16 | let(:readme_contents) { '' }
17 |
18 | before {
19 | YARD::Registry.clear
20 | YardJunk::Logger.instance.clear
21 | YardJunk::Logger.instance.format = nil
22 |
23 | YARD.parse_string(source)
24 | described_class.resolve_all(fake_options)
25 | }
26 |
27 | context 'code objects' do
28 | let(:source) { %{
29 | # It meant to be code: {'message' => 'test'}
30 | def foo
31 | end
32 | }}
33 |
34 | # In newer Rubies, it is "smartly" rendered with a smart quotes, in older ones it is not. Thanks, RDoc!
35 | its(:last) { is_expected.to have_attributes(message: /^Cannot resolve link to [‘']message[’'] from text: {[‘']message[’'] => [‘']test[’']}$/, line: 3) }
36 |
37 | context 'for RDoc' do
38 | let(:markup) { :rdoc }
39 |
40 | # In newer Rubies, it is "smartly" rendered with a smart quotes, in older ones it is not. Thanks, RDoc!
41 | its(:last) { is_expected.to have_attributes(message: /^Cannot resolve link to [‘']message[’'] from text: {[‘']message[’'] => [‘']test[’']}$/, line: 3) }
42 | end
43 | end
44 |
45 | context 'file:' do
46 | context 'valid' do
47 | let(:source) { %{
48 | # {file:README.md}
49 | def foo
50 | end
51 | }}
52 |
53 | its(:last) { is_expected.to be_nil }
54 | end
55 |
56 | context 'invalid' do
57 | let(:source) { %{
58 | # {file:GettingStarted.md}
59 | def foo
60 | end
61 | }}
62 |
63 | its(:last) { is_expected.to have_attributes(message: "File 'GettingStarted.md' does not exist: {file:GettingStarted.md}", line: 3) }
64 | end
65 |
66 | context 'existing, but not included in YARD list'
67 | context 'included in YARD list, but not existing'
68 | end
69 |
70 | context 'include:'
71 | context 'include:file:'
72 | context 'render:'
73 |
74 | context 'url' do
75 | # With RDoc as a default renderer (both for :rdoc and :markdown) on Ruby 2.6+, it will
76 | # auto-link the http://, and then YARD will fail!
77 | let(:markup) { :markdown }
78 | let(:options) { super().merge(markup_provider: :kramdown) }
79 | let(:source) { %{
80 | # {http://google.com Google}
81 | def foo
82 | end
83 | }}
84 |
85 | its(:last) { is_expected.to be_nil }
86 | end
87 |
88 | context 'check in files' do
89 | let(:readme_contents) { 'Is it {Foo}?' }
90 | let(:source) { '' }
91 |
92 | its(:last) { is_expected.to have_attributes(message: 'Cannot resolve link to Foo from text: {Foo}') }
93 |
94 | context 'RDoc readme' do
95 | let(:readme) {
96 | # Not an instance_double, because resolver checks object class
97 | YARD::CodeObjects::ExtraFileObject.new('README.rdoc', readme_contents).tap do |f|
98 | allow(f).to receive_messages(name: 'README', filename: 'README.rdoc')
99 | end
100 | }
101 | let(:readme_contents) { 'Is it {Foo}?' }
102 |
103 | its(:last) { is_expected.to have_attributes(message: 'Cannot resolve link to Foo from text: {Foo}') }
104 | end
105 |
106 | context 'Markdown README with rdoc settings' do
107 | let(:markup) { :rdoc }
108 | let(:readme_contents) { 'Is it `{Foo}`?' }
109 |
110 | its(:last) { is_expected.to be_nil }
111 | end
112 | end
113 | end
114 | end
115 |
--------------------------------------------------------------------------------
/spec/yard-junk/janitor/text_reporter_spec.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | RSpec.describe YardJunk::Janitor::TextReporter do
4 | let(:out) { StringIO.new }
5 | let(:reporter) { described_class.new(out) }
6 |
7 | describe '#section' do
8 | subject {
9 | reporter.section(
10 | 'Section',
11 | 'Explanation',
12 | messages
13 | )
14 | }
15 |
16 | let(:messages) {
17 | [
18 | YardJunk::Logger::Message.new(message: 'Something bad', file: 'file.rb', line: 10),
19 | YardJunk::Logger::Message.new(message: 'Something bad', file: 'file.rb', line: 10)
20 | ]
21 | }
22 |
23 | its_block {
24 | is_expected
25 | .to send_message(out, :puts).with(no_args)
26 | .and send_message(out, :puts).with('Section')
27 | .and send_message(out, :puts).with('-------')
28 | .and send_message(out, :puts).with("Explanation\n\n")
29 | .and send_message(reporter, :row).exactly(2).times
30 | }
31 |
32 | context 'ordering' do
33 | let(:first) { YardJunk::Logger::Message.new(message: 'Something bad 1', file: 'file.rb', line: 10) }
34 | let(:second) { YardJunk::Logger::Message.new(message: 'Something bad 2', file: 'file.rb', line: 15) }
35 | let(:third) { YardJunk::Logger::Message.new(message: 'Something bad 2', file: 'other_file.rb', line: 5) }
36 | let(:messages) { [third, second, first] }
37 |
38 | its_block {
39 | is_expected
40 | .to send_message(reporter, :row).with(first).ordered
41 | .and send_message(reporter, :row).with(second).ordered
42 | .and send_message(reporter, :row).with(third).ordered
43 | }
44 | end
45 |
46 | context 'empty messages' do
47 | let(:messages) { [] }
48 |
49 | its_block { is_expected.not_to send_message(out, :puts) }
50 | end
51 | end
52 |
53 | describe '#row' do
54 | subject { reporter.send(:row, YardJunk::Logger::Message.new(message: 'Something bad', file: 'file.rb', line: 10)) }
55 |
56 | its_block { is_expected.to send_message(out, :puts).with('file.rb:10: [UnknownError] Something bad') }
57 | end
58 |
59 | describe '#stats' do
60 | subject { reporter.stats(**stats) }
61 |
62 | shared_context 'with colors' do
63 | around { |ex|
64 | prev = Rainbow.enabled
65 | Rainbow.enabled = true
66 | ex.run
67 | Rainbow.enabled = prev
68 | }
69 | end
70 |
71 | shared_context 'without colors' do
72 | around { |ex|
73 | prev = Rainbow.enabled
74 | Rainbow.enabled = false
75 | ex.run
76 | Rainbow.enabled = prev
77 | }
78 | end
79 |
80 | context 'there are errors' do
81 | let(:stats) { {errors: 3, problems: 2, duration: 5.2} }
82 |
83 | include_context 'with colors'
84 |
85 | its_block {
86 | is_expected
87 | .to send_message(out, :puts)
88 | .with("\n\e[31m3 failures, 2 problems\e[0m (5 seconds to run)")
89 | }
90 | end
91 |
92 | context 'there are problems' do
93 | let(:stats) { {errors: 0, problems: 2, duration: 5.2} }
94 |
95 | include_context 'with colors'
96 |
97 | its_block {
98 | is_expected
99 | .to send_message(out, :puts)
100 | .with("\n\e[33m0 failures, 2 problems\e[0m (5 seconds to run)")
101 | }
102 | end
103 |
104 | context 'everything is ok' do
105 | let(:stats) { {errors: 0, problems: 0, duration: 5.2} }
106 |
107 | include_context 'with colors'
108 |
109 | its_block {
110 | is_expected
111 | .to send_message(out, :puts)
112 | .with("\n\e[32m0 failures, 0 problems\e[0m (5 seconds to run)")
113 | }
114 | end
115 |
116 | context 'TTY does not support colors' do
117 | let(:stats) { {errors: 3, problems: 2, duration: 5.2} }
118 |
119 | include_context 'without colors'
120 |
121 | its_block {
122 | is_expected
123 | .to send_message(out, :puts)
124 | .with("\n3 failures, 2 problems (5 seconds to run)")
125 | }
126 | end
127 | end
128 |
129 | describe '#finalize' do
130 | subject { reporter.finalize }
131 |
132 | its_block { is_expected.not_to send_message(out, :puts) }
133 | end
134 | end
135 |
--------------------------------------------------------------------------------
/spec/yard-junk/janitor_spec.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | RSpec.describe YardJunk::Janitor do
4 | subject(:janitor) { described_class.new }
5 |
6 | before { YardJunk::Logger.instance.clear }
7 |
8 | describe '#run' do
9 | subject { janitor.run }
10 |
11 | let(:command) { instance_double(YARD::CLI::Yardoc, run: nil, options: OpenStruct.new(files: [])) }
12 |
13 | its_block {
14 | is_expected
15 | .to send_message(YARD::Registry, :clear)
16 | .and send_message(YardJunk::Logger.instance, :format=)
17 | .with(nil).calling_original
18 | .and send_message(YARD::CLI::Yardoc, :new)
19 | .returning(command)
20 | .and send_message(command, :run)
21 | .with('--no-save', '--no-progress', '--no-stats', '--no-output', '--no-cache')
22 | .and send_message(YardJunk::Janitor::Resolver, :resolve_all)
23 | .and output("Running YardJunk janitor (version #{YardJunk::VERSION})...\n\n").to_stdout
24 | }
25 | end
26 |
27 | def data_for_report
28 | logger = YardJunk::Logger.instance
29 | logger.format = nil
30 | logger.register('Unknown tag @wrong in file `input/lot_of_errors.rb` near line 26')
31 | logger.register('@param tag has duplicate parameter name: para in file `input/lot_of_errors.rb\' near line 33')
32 | logger.register('input/circular_ref.rb:5: Detected circular reference tag in `Foo#b\', ignoring all reference tags for this object (@param).', :error)
33 | logger.register("Syntax error in `input/nested/unparseable.rb`:(3,4): syntax error, unexpected '\\n', expecting &. or :: or '[' or '.'")
34 | janitor.instance_variable_set('@duration', 250.6) # :shrug:
35 | end
36 |
37 | describe '#stats' do
38 | subject { janitor.stats }
39 |
40 | context 'initial' do
41 | it { is_expected.to eq(errors: 0, problems: 0, duration: 0) }
42 | end
43 |
44 | context 'after run' do
45 | before { data_for_report }
46 |
47 | it { is_expected.to eq(errors: 2, problems: 2, duration: 250.6) }
48 | end
49 | end
50 |
51 | describe '#exit_code' do
52 | context 'by default' do
53 | its(:exit_code) { is_expected.to eq 0 }
54 | end
55 |
56 | context 'with problems' do
57 | before { data_for_report }
58 |
59 | its(:exit_code) { is_expected.to eq 2 }
60 | end
61 | end
62 |
63 | describe '#report' do
64 | subject { janitor.report(:text) }
65 |
66 | before {
67 | data_for_report
68 | allow(YardJunk::Janitor::TextReporter).to receive(:new).and_return(reporter)
69 | }
70 |
71 | let(:reporter) { instance_double(YardJunk::Janitor::BaseReporter, section: nil, stats: nil, finalize: nil) }
72 |
73 | its_block {
74 | is_expected
75 | .to send_message(reporter, :section)
76 | .with('Errors', 'severe code or formatting problems',
77 | an_instance_of(Array).and(have_attributes(count: 2))
78 | .and(all(be_a(YardJunk::Logger::Message))).and(all(be_error)))
79 | .and send_message(reporter, :section)
80 | .with('Problems', 'mistyped tags or other typos in documentation',
81 | an_instance_of(Array).and(have_attributes(count: 2))
82 | .and(all(be_a(YardJunk::Logger::Message))).and(all(be_warn)))
83 | .and send_message(reporter, :stats)
84 | .with(errors: 2, problems: 2, duration: 250.6)
85 | .and send_message(reporter, :finalize)
86 | }
87 |
88 | context 'with pathes specified', skip: 'Tested manually, hard to imitate everything with FakeFS' do
89 | include FakeFS::SpecHelpers
90 |
91 | subject { janitor.report(:text, path: path) }
92 |
93 | before {
94 | # It would be fake files and folders, provided by FakeFS
95 | FileUtils.mkdir_p 'input/nested'
96 | %w[input/lot_of_errors.rb input/circular_ref.rb input/nested/unparseable.rb]
97 | .each { |path| File.write path, '---' }
98 | }
99 |
100 | context 'specific file' do
101 | let(:path) { 'input/lot_of_errors.rb' }
102 |
103 | its_block {
104 | is_expected
105 | .to send_message(reporter, :section)
106 | .with('Errors', 'severe code or formatting problems', [])
107 | .and send_message(reporter, :section)
108 | .with('Problems', 'mistyped tags or other typos in documentation',
109 | an_instance_of(Array).and(have_attributes(count: 2))
110 | .and(all(be_a(YardJunk::Logger::Message))).and(all(be_warn)))
111 | .and send_message(reporter, :stats)
112 | .with(errors: 0, problems: 2, duration: 250.6)
113 | .and send_message(reporter, :finalize)
114 | }
115 | end
116 |
117 | context 'pattern' do
118 | before { allow(Dir).to receive(:[]).with('input/*.rb').and_return(['input/lot_of_errors.rb', 'input/circular_ref.rb']) }
119 |
120 | let(:path) { 'input/*.rb' }
121 |
122 | its_block {
123 | is_expected
124 | .to send_message(reporter, :section)
125 | .with('Errors', 'severe code or formatting problems',
126 | an_instance_of(Array).and(have_attributes(count: 1))
127 | .and(all(be_a(YardJunk::Logger::Message))).and(all(be_error)))
128 | .and send_message(reporter, :section)
129 | .with('Problems', 'mistyped tags or other typos in documentation',
130 | an_instance_of(Array).and(have_attributes(count: 2))
131 | .and(all(be_a(YardJunk::Logger::Message))).and(all(be_warn)))
132 | .and send_message(reporter, :stats)
133 | .with(errors: 0, problems: 2, duration: 250.6)
134 | .and send_message(reporter, :finalize)
135 | }
136 | end
137 |
138 | context 'folder' do
139 | before { allow(Dir).to receive(:[]).with('input/nested').and_return(['input/nested/unparseable.rb']) }
140 |
141 | let(:path) { 'input/nested' }
142 |
143 | its_block {
144 | is_expected
145 | .to send_message(reporter, :section)
146 | .with('Errors', 'severe code or formatting problems',
147 | an_instance_of(Array).and(have_attributes(count: 1))
148 | .and(all(be_a(YardJunk::Logger::Message))).and(all(be_error)))
149 | .and send_message(reporter, :section)
150 | .with('Problems', 'mistyped tags or other typos in documentation', [])
151 | .and send_message(reporter, :stats)
152 | .with(errors: 1, problems: 0, duration: 250.6)
153 | .and send_message(reporter, :finalize)
154 | }
155 | end
156 |
157 | context 'array of pathes'
158 | end
159 | end
160 | end
161 |
--------------------------------------------------------------------------------
/spec/yard-junk/integration/inject_in_parsing_spec.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | RSpec.describe 'Integration: catching errors' do
4 | # include FakeFS::SpecHelpers
5 |
6 | subject(:logger) { YardJunk::Logger.instance }
7 |
8 | before(:all) do
9 | YARD::Logger.prepend(YardJunk::Logger::Mixin)
10 | end
11 |
12 | after(:all) do
13 | YARD::Registry.clear
14 | end
15 |
16 | def parse_file(contents)
17 | # It would be "fake" file, provided by FakeFS and stored nowhere
18 | FakeFS do
19 | File.write('test.rb', contents)
20 | YARD.parse('test.rb')
21 | end
22 | end
23 |
24 | before {
25 | logger.clear
26 | logger.format = nil # do not print messages to STDOUT
27 | }
28 |
29 | shared_examples_for 'file parser' do |description, code, message|
30 | context description do
31 | let(:defaults) { {file: 'test.rb', line: 1} }
32 |
33 | before { parse_file(code) }
34 |
35 | its(:'messages.last.to_h') { is_expected
36 | .to eq(defaults.merge(message))
37 | }
38 | end
39 | end
40 |
41 | it_behaves_like 'file parser', 'unknown tag',
42 | %{
43 | # @hello world
44 | def foo
45 | end
46 | },
47 | type: 'UnknownTag',
48 | message: 'Unknown tag @hello',
49 | tag: '@hello',
50 | line: 2
51 |
52 | it_behaves_like 'file parser', 'unknown tag: no location',
53 | %{
54 | # @hello world
55 | },
56 | type: 'UnknownTag',
57 | message: 'Unknown tag @hello',
58 | tag: '@hello'
59 |
60 | it_behaves_like 'file parser', 'unknown tag: did you mean?',
61 | %{
62 | # @raises NoMethodError
63 | def foo
64 | end
65 | },
66 | type: 'UnknownTag',
67 | message: 'Unknown tag @raises. Did you mean @raise?',
68 | tag: '@raises',
69 | line: 2
70 |
71 | it_behaves_like 'file parser', 'invalid tag format',
72 | %{
73 | # @example
74 | def bar
75 | end
76 | },
77 | type: 'InvalidTagFormat',
78 | message: 'Invalid tag format for @example',
79 | tag: '@example',
80 | line: 2
81 |
82 | it_behaves_like 'file parser', 'unknown directive',
83 | %{
84 | # @!hello world
85 | def foo
86 | end
87 | },
88 | type: 'UnknownDirective',
89 | message: 'Unknown directive @!hello',
90 | directive: '@!hello',
91 | line: 2
92 |
93 | it_behaves_like 'file parser', 'invalid directive format',
94 | %{
95 | # @!macro
96 | def bar
97 | end
98 | },
99 | type: 'InvalidDirectiveFormat',
100 | message: 'Invalid directive format for @!macro',
101 | directive: '@!macro',
102 | line: 2
103 |
104 | it_behaves_like 'file parser', 'unknown parameter',
105 | %{
106 | # @param notaparam foo
107 | def foo(a) end
108 | },
109 | type: 'UnknownParam',
110 | message: '@param tag has unknown parameter name: notaparam',
111 | param_name: 'notaparam',
112 | line: 2
113 |
114 | it_behaves_like 'file parser', 'unknown parameter: did you mean',
115 | %{
116 | # @param tuples foo
117 | def foo(tuple) end
118 | },
119 | type: 'UnknownParam',
120 | message: '@param tag has unknown parameter name: tuples. Did you mean `tuple`?',
121 | param_name: 'tuples',
122 | line: 2
123 |
124 | it_behaves_like 'file parser', 'unknown parameter without name',
125 | %{
126 | # @param [String]
127 | def foo(a) end
128 | },
129 | type: 'MissingParamName',
130 | message: '@param tag has empty parameter name',
131 | line: 2
132 |
133 | it_behaves_like 'file parser', 'unknown parameter for generated method',
134 | %{
135 | # @!method join(delimiter, null_repr)
136 | # Convert the array to a string by joining
137 | # values with a delimiter (empty string by default)
138 | # and optional filler for NULL values
139 | # Translates to an `array_to_string` call
140 | #
141 | # @param [Object] delimiter
142 | # @param [Object] null
143 | #
144 | # @return [SQL::Attribute]
145 | #
146 | # @api public
147 | },
148 | type: 'UnknownParam',
149 | message: '@param tag has unknown parameter name: null',
150 | param_name: 'null',
151 | line: 2
152 |
153 | it_behaves_like 'file parser', 'duplicate parameter',
154 | %{
155 | # @param para
156 | # @param para
157 | def bar(para)
158 | end
159 | },
160 | type: 'DuplicateParam',
161 | message: '@param tag has duplicate parameter name: para',
162 | param_name: 'para',
163 | line: 3
164 |
165 | syntax_error = case
166 | when RUBY_ENGINE == 'jruby'
167 | 'syntax error, unexpected end-of-file'
168 | when RUBY_VERSION >= '2.6'
169 | 'syntax error, unexpected end-of-input'
170 | else
171 | "syntax error, unexpected end-of-input, expecting '('"
172 | end
173 |
174 | it_behaves_like 'file parser', 'syntax error',
175 | %{
176 | foo, bar.
177 | },
178 | type: 'SyntaxError',
179 | message: syntax_error,
180 | line: 3
181 |
182 | it_behaves_like 'file parser', 'circular reference',
183 | %{
184 | class Foo
185 | # @param (see #b)
186 | def a; end
187 | # @param (see #a)
188 | def b; end
189 | end
190 | },
191 | type: 'CircularReference',
192 | message: "Detected circular reference tag in `Foo#b', ignoring all reference tags for this object (@param).",
193 | object: 'Foo#b',
194 | context: '@param',
195 | line: 6
196 |
197 | it_behaves_like 'file parser', 'undocumentable',
198 | %{
199 | attr_reader *OPTIONS
200 | },
201 | type: 'Undocumentable',
202 | message: 'Undocumentable OPTIONS: `attr_reader *OPTIONS`',
203 | quote: 'attr_reader *OPTIONS',
204 | object: 'OPTIONS',
205 | line: 2
206 |
207 | it_behaves_like 'file parser', 'not recognized',
208 | %{
209 | Bar::BOOKS = 5
210 | },
211 | type: 'UnknownNamespace',
212 | message: 'namespace Bar is not recognized',
213 | namespace: 'Bar'
214 |
215 | it_behaves_like 'file parser', 'macro attaching error',
216 | %{
217 | # @!macro [attach] attached4
218 | # $1 $2 $3
219 | class A
220 | end
221 | },
222 | type: 'MacroAttachError',
223 | message: 'Attaching macros to non-methods is unsupported, ignoring: A',
224 | object: 'A',
225 | line: 2
226 |
227 | it_behaves_like 'file parser', 'macro name error',
228 | %{
229 | # @!macro wtf
230 | def foo
231 | end
232 | },
233 | type: 'MacroNameError',
234 | message: 'Invalid/missing macro name for #foo',
235 | object: '#foo',
236 | line: 3
237 |
238 | it_behaves_like 'file parser', 'redundant braces',
239 | %{
240 | # @see {invalid}
241 | def foo
242 | end
243 | },
244 | type: 'RedundantBraces',
245 | message: '@see tag should not be wrapped in {} (causes rendering issues)',
246 | line: 2
247 |
248 | # TODO: DRY!
249 | context 'invalid link' do
250 | include YARD::Templates::Helpers::BaseHelper
251 | include YARD::Templates::Helpers::HtmlHelper
252 |
253 | before {
254 | parse_file(%{
255 | # Comments here
256 | # And a reference to {InvalidObject}
257 | class MyObject; end
258 | })
259 | allow(self).to receive(:object).and_return(YARD::Registry.at('MyObject'))
260 | resolve_links(YARD::Registry.at('MyObject').docstring)
261 | }
262 |
263 | its(:'messages.last.to_h') { is_expected
264 | .to eq(type: 'InvalidLink', message: 'Cannot resolve link to InvalidObject from text: ...{InvalidObject}', object: 'InvalidObject', quote: '...{InvalidObject}', file: 'test.rb', line: 3)
265 | }
266 | end
267 | end
268 |
--------------------------------------------------------------------------------
/lib/yard-junk/logger/message.rb:
--------------------------------------------------------------------------------
1 | # frozen_string_literal: true
2 |
3 | require_relative 'spellcheck'
4 |
5 | module YardJunk
6 | class Logger
7 | class Message
8 | attr_reader :message, :severity, :file, :line, :extra
9 |
10 | def initialize(message:, severity: :warn, code_object: nil, file: nil, line: nil, **extra)
11 | @message = message.gsub(/\s{2,}/, ' ')
12 | @file = file
13 | @line = line&.to_i
14 | @code_object = code_object
15 | @severity = severity
16 | @extra = extra
17 | end
18 |
19 | %i[error warn].each do |sev|
20 | define_method("#{sev}?") { severity == sev }
21 | end
22 |
23 | def to_h
24 | {
25 | type: type,
26 | message: message,
27 | file: file,
28 | line: line&.to_i || 1
29 | }.merge(extra)
30 | end
31 |
32 | def ==(other)
33 | other.is_a?(self.class) && to_h == other.to_h
34 | end
35 |
36 | DEFAULT_FORMAT = '%{file}:%{line}: [%{type}] %{message}'
37 |
38 | def to_s(format = DEFAULT_FORMAT)
39 | format % to_h
40 | end
41 |
42 | def type
43 | self.class.type
44 | end
45 |
46 | include Spellcheck
47 |
48 | class << self
49 | def registry
50 | @registry ||= []
51 | end
52 |
53 | def pattern(regexp)
54 | @pattern = regexp
55 | Message.registry << self
56 | end
57 |
58 | def search_up(pattern)
59 | @search_up = pattern
60 | end
61 |
62 | def try_parse(line, **context)
63 | @pattern or fail StandardError, "Pattern is not defined for #{self}"
64 | match = @pattern.match(line) or return nil
65 | data = context.compact
66 | .merge(match.names.map(&:to_sym).zip(match.captures).to_h.compact)
67 | data = guard_line(data)
68 | new(**data)
69 | end
70 |
71 | def type
72 | !name || name.end_with?('::Message') ? 'UnknownError' : name.sub(/^.+::/, '')
73 | end
74 |
75 | def valid_type?(type)
76 | type == 'UnknownError' || registry.any? { |m| m.type == type }
77 | end
78 |
79 | private
80 |
81 | def guard_line(data) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
82 | # FIXME: Ugly, huh?
83 | data[:file] && data[:line] && @search_up or return data
84 | data = data.merge(line: data[:line].to_i)
85 | data = data.merge(code_object: find_object(data[:file], data[:line]))
86 | lines = File.readlines(data[:file]) rescue (return data) # rubocop:disable Style/RescueModifier
87 | pattern = Regexp.new(@search_up % data.transform_values { |v| Regexp.escape(v.to_s) })
88 | _, num = lines.map
89 | .with_index { |ln, i| [ln, i + 1] }
90 | .first(data[:line]).reverse
91 | .detect { |ln,| pattern.match(ln) }
92 | num or return data
93 |
94 | data.merge(line: num)
95 | end
96 |
97 | def find_object(file, line)
98 | YARD::Registry.detect { |o| o.file == file && o.line == line }
99 | end
100 | end
101 | end
102 |
103 | # rubocop:disable Layout/LineLength
104 | class UnknownTag < Message
105 | pattern %r{^(?Unknown tag (?@\S+))( in file `(?[^`]+)` near line (?\d+))?$}
106 | search_up '%{tag}(\W|$)'
107 |
108 | def message
109 | corrections.empty? ? super : "#{super}. Did you mean #{corrections.map { |c| "@#{c}" }.join(', ')}?"
110 | end
111 |
112 | private
113 |
114 | def corrections
115 | spell_check(extra[:tag], YARD::Tags::Library.labels.keys.map(&:to_s))
116 | end
117 | end
118 |
119 | class InvalidTagFormat < Message
120 | pattern %r{^(?Invalid tag format for (?@\S+))( in file `(?[^`]+)` near line (?\d+))?$}
121 | search_up '%{tag}(\W|$)'
122 | end
123 |
124 | class UnknownDirective < Message
125 | pattern %r{^(?Unknown directive (?@!\S+))( in file `(?[^`]+)` near line (?\d+))?$}
126 | search_up '%{directive}(\W|$)'
127 |
128 | # TODO: did_you_mean?
129 | end
130 |
131 | class InvalidDirectiveFormat < Message
132 | pattern %r{^(?Invalid directive format for (?@!\S+))( in file `(?[^`]+)` near line (?\d+))?$}
133 | search_up '%{directive}(\W|$)'
134 | end
135 |
136 | class UnknownParam < Message
137 | pattern %r{^(?@param tag has unknown parameter name: (?\S+))\s+ in file `(?[^']+)' near line (?\d+)$}
138 | search_up '@param(\s+\[.+?\])?\s+?%{param_name}(\W|$)'
139 |
140 | def message
141 | corrections.empty? ? super : "#{super}. Did you mean #{corrections.map { |c| "`#{c}`" }.join(', ')}?"
142 | end
143 |
144 | private
145 |
146 | def corrections
147 | spell_check(extra[:param_name], known_params)
148 | end
149 |
150 | def known_params
151 | @code_object.is_a?(YARD::CodeObjects::MethodObject) or return []
152 | @code_object.parameters.map(&:first).map { |p| p.tr('*&:', '') }
153 | end
154 | end
155 |
156 | class MissingParamName < Message
157 | pattern %r{^(?@param tag has unknown parameter name):\s+in file `(?[^']+)' near line (?\d+)$}
158 | search_up '@param(\s+\[.+?\])?\s*$'
159 |
160 | def message
161 | '@param tag has empty parameter name'
162 | end
163 | end
164 |
165 | class DuplicateParam < Message
166 | pattern %r{^(?@param tag has duplicate parameter name: (?\S+))\s+ in file `(?[^']+)' near line (?\d+)$}
167 | search_up '@param\s+(\[.+?\]\s+)?%{param_name}(\W|$)'
168 | end
169 |
170 | class RedundantBraces < Message
171 | pattern %r{^(?@see tag \(\#\d+\) should not be wrapped in \{\} \(causes rendering issues\)):\s+in file `(?[^']+)' near line (?\d+)$}
172 | search_up '@see.*{.*}'
173 |
174 | def message
175 | super.sub(/\s+\(\#\d+\)\s+/, ' ')
176 | end
177 | end
178 |
179 | class SyntaxError < Message
180 | pattern %r{^Syntax error in `(?[^`]+)`:\((?\d+),(?:\d+)\): (?.+)$}
181 |
182 | # Honestly, IDK why YARD considers it "warning"... So, rewriting
183 | def severity
184 | :error
185 | end
186 | end
187 |
188 | class CircularReference < Message
189 | pattern %r{^(?.+?):(?\d+): (?Detected circular reference tag in `(?