yard-junk 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e2e9b802aa1bb3391b0962165574b75f10e05cad
+  data.tar.gz: 6b279f93f06feb8ea1c10595d10cc8661f7bcc8d
+SHA512:
+  metadata.gz: 381f8c03346812eef369dabc6548c675aef0c309f7cd08b767c0e3603ef1267f08b589acb994789f410039601108aa7cd3de46b42f3e8fc539d683a28b50975b
+  data.tar.gz: d9c65f218d51d23bb573671f9e89c62497bbed28063487a06ede45a1e1d97abd54dd5311e095d2944936d665ef86471dd0f1b385279906a17e5d7be9316a874a

data/.rubocop_todo.yml

@@ -0,0 +1 @@
+

data/.yardopts

@@ -0,0 +1,2 @@
+--markup markdown
+-e ./lib/yard-junk.rb

data/README.md

@@ -0,0 +1,297 @@
+# Yard-Junk: get rid of junk in your YARD docs!
+
+[![Gem Version](https://badge.fury.io/rb/yard-junk.svg)](http://badge.fury.io/rb/yard-junk)
+[![Build Status](https://travis-ci.org/zverok/yard-junk.svg?branch=master)](https://travis-ci.org/zverok/yard-junk)
+
+Yard-Junk is [yard](https://github.com/lsegal/yard) plugin/patch, that provides:
+
+* structured documentation error logging;
+* documentation errors validator, ready to be integrated into CI pipeline.
+
+## Showcase
+
+Let's generate the docs for the [rom](https://github.com/rom-rb/rom) library.
+
+Output of `yard doc` without JunkYard: [too huge to embed in README](https://gist.github.com/zverok/6dcf946d674e63545cee9f8a74e08728).
+
+Things to notice:
+
+* irregular and frequently approximate addresses (`in file 'core/lib/rom/types.rb':9`,
+  `in file 'core/lib/rom/global.rb' near line 41`, sometimes in separate line, sometimes inline),
+  hard to jump-to with any tool;
+* a lot of ununderstood metaprogramming (grep for "Undocumentable mixin") -- nothing to fix here,
+  but YARD still notifies you;
+* verbose and not very informative errors (look at that "Undocumentable mixin" -- and then grep
+  for "The proxy Coercible has not yet been recognized." and compare).
+
+Output of `yard doc` with Yard-Junk:
+
+```
+core/lib/rom/global.rb:40: [InvalidTagFormat] Invalid tag format for @example
+core/lib/rom/schema.rb:144: [MissingParamName] @param tag has empty parameter name
+core/lib/rom/schema.rb:300: [MissingParamName] @param tag has empty parameter name
+core/lib/rom/schema.rb:311: [MissingParamName] @param tag has empty parameter name
+core/lib/rom/gateway.rb:171: [UnknownParam] @param tag has unknown parameter name: Transaction
+core/lib/rom/relation.rb:297: [UnknownParam] @param tag has unknown parameter name: options
+core/lib/rom/relation.rb:406: [UnknownParam] @param tag has unknown parameter name: new_options
+core/lib/rom/relation.rb:524: [UnknownParam] @param tag has unknown parameter name: klass
+core/lib/rom/attribute.rb:339: [MissingParamName] @param tag has empty parameter name
+core/lib/rom/plugin_base.rb:38: [UnknownParam] @param tag has unknown parameter name: base. Did you mean `_base`?
+core/lib/rom/configuration.rb:46: [UnknownParam] @param tag has unknown parameter name: The
+core/lib/rom/configuration.rb:47: [UnknownParam] @param tag has unknown parameter name: Plugin. Did you mean `plugin`?
+core/lib/rom/memory/dataset.rb:54: [UnknownParam] @param tag has unknown parameter name: names
+core/lib/rom/plugin_registry.rb:140: [UnknownTag] Unknown tag @raises. Did you mean @raise?
+core/lib/rom/plugin_registry.rb:187: [UnknownTag] Unknown tag @raises. Did you mean @raise?
+core/lib/rom/relation/loaded.rb:91: [UnknownTag] Unknown tag @raises. Did you mean @raise?
+core/lib/rom/command_registry.rb:52: [UnknownParam] @param tag has unknown parameter name: name
+core/lib/rom/relation/curried.rb:69: [UnknownTag] Unknown tag @raises. Did you mean @raise?
+core/lib/rom/global/plugin_dsl.rb:41: [UnknownParam] @param tag has unknown parameter name: adapter
+core/lib/rom/relation/combined.rb:28: [MissingParamName] @param tag has empty parameter name
+core/lib/rom/commands/class_interface.rb:78: [UnknownParam] @param tag has unknown parameter name: command
+core/lib/rom/commands/class_interface.rb:79: [UnknownParam] @param tag has unknown parameter name: parent
+core/lib/rom/commands/class_interface.rb:108: [UnknownParam] @param tag has unknown parameter name: options. Did you mean `_options`?
+core/lib/rom/commands/class_interface.rb:118: [MissingParamName] @param tag has empty parameter name
+core/lib/rom/associations/definitions/abstract.rb:66: [UnknownParam] @param tag has unknown parameter name: options
+changeset/lib/rom/changeset.rb:79: [UnknownParam] @param tag has unknown parameter name: options. Did you mean `new_options`?
+changeset/lib/rom/changeset/stateful.rb:219: [UnknownParam] @param tag has unknown parameter name: assoc
+mapper/lib/rom/header.rb:47: [UnknownParam] @param tag has unknown parameter name: model
+mapper/lib/rom/processor/transproc.rb:212: [MissingParamName] @param tag has empty parameter name
+core/lib/rom/types.rb:1: [UnknownNamespace] namespace Coercible is not recognized
+core/lib/rom/types.rb:1: [UnknownNamespace] namespace Coercible is not recognized
+core/lib/rom/types.rb:1: [UnknownNamespace] namespace Coercible is not recognized
+```
+
+Things to notice:
+
+* Regular output style with clearly recognizable addresses (and fixed to point at actual line with
+  the problematic tag, not the method which tag is related for);
+* Error classes, allowing grouping, grepping, and configuring (notice no "Undocumentable xxx" errors:
+  I've just configured `yard-junk` to drop them for this repo);
+* Usage of Ruby's bundled `did_you_mean` gem to show reasonable suggestions:
+```
+Unknown tag @raises. Did you mean @raise?
+@param tag has unknown parameter name: options. Did you mean `new_options`?
+```
+* Rephrased and cleaned up messages.
+
+`yard-junk` tool output:
+
+```
+Problems
+--------
+mistyped tags or other typos in documentation
+
+changeset/lib/rom/changeset.rb:79: [UnknownParam] @param tag has unknown parameter name: options. Did you mean `new_options`?
+changeset/lib/rom/changeset/stateful.rb:219: [UnknownParam] @param tag has unknown parameter name: assoc
+core/lib/rom/associations/definitions/abstract.rb:66: [UnknownParam] @param tag has unknown parameter name: options
+core/lib/rom/attribute.rb:339: [MissingParamName] @param tag has empty parameter name
+core/lib/rom/command_registry.rb:52: [UnknownParam] @param tag has unknown parameter name: name
+core/lib/rom/commands/class_interface.rb:78: [UnknownParam] @param tag has unknown parameter name: command
+core/lib/rom/commands/class_interface.rb:79: [UnknownParam] @param tag has unknown parameter name: parent
+core/lib/rom/commands/class_interface.rb:108: [UnknownParam] @param tag has unknown parameter name: options. Did you mean `_options`?
+core/lib/rom/commands/class_interface.rb:118: [MissingParamName] @param tag has empty parameter name
+core/lib/rom/configuration.rb:46: [UnknownParam] @param tag has unknown parameter name: The
+core/lib/rom/configuration.rb:47: [UnknownParam] @param tag has unknown parameter name: Plugin. Did you mean `plugin`?
+core/lib/rom/gateway.rb:171: [UnknownParam] @param tag has unknown parameter name: Transaction
+core/lib/rom/global.rb:40: [InvalidTagFormat] Invalid tag format for @example
+core/lib/rom/global/plugin_dsl.rb:41: [UnknownParam] @param tag has unknown parameter name: adapter
+core/lib/rom/memory/dataset.rb:54: [UnknownParam] @param tag has unknown parameter name: names
+core/lib/rom/plugin_base.rb:38: [UnknownParam] @param tag has unknown parameter name: base. Did you mean `_base`?
+core/lib/rom/plugin_registry.rb:140: [UnknownTag] Unknown tag @raises. Did you mean @raise?
+core/lib/rom/plugin_registry.rb:187: [UnknownTag] Unknown tag @raises. Did you mean @raise?
+core/lib/rom/relation.rb:297: [UnknownParam] @param tag has unknown parameter name: options
+core/lib/rom/relation.rb:406: [UnknownParam] @param tag has unknown parameter name: new_options
+core/lib/rom/relation.rb:524: [UnknownParam] @param tag has unknown parameter name: klass
+core/lib/rom/relation/combined.rb:28: [MissingParamName] @param tag has empty parameter name
+core/lib/rom/relation/curried.rb:69: [UnknownTag] Unknown tag @raises. Did you mean @raise?
+core/lib/rom/relation/loaded.rb:91: [UnknownTag] Unknown tag @raises. Did you mean @raise?
+core/lib/rom/schema.rb:144: [MissingParamName] @param tag has empty parameter name
+core/lib/rom/schema.rb:300: [MissingParamName] @param tag has empty parameter name
+core/lib/rom/schema.rb:311: [MissingParamName] @param tag has empty parameter name
+core/lib/rom/types.rb:1: [UnknownNamespace] namespace Coercible is not recognized
+core/lib/rom/types.rb:1: [UnknownNamespace] namespace Coercible is not recognized
+core/lib/rom/types.rb:1: [UnknownNamespace] namespace Coercible is not recognized
+mapper/lib/rom/header.rb:47: [UnknownParam] @param tag has unknown parameter name: model
+mapper/lib/rom/processor/transproc.rb:212: [MissingParamName] @param tag has empty parameter name
+
+0 failures, 32 problems (2 seconds to run)
+```
+
+It is basically the same as above, and:
+
+* sorted by files/lines instead of "reported when found" approach;
+* with short stats at the end;
+* returning proper exit code (0 if no problems/parsing errors, non-0 otherwise), which allows `yard-junk`
+  to be integrated into CI pipeline, and control that new PRs will not screw docs (forgetting to
+  rename parameters in docs when they are renamed in code, for example).
+
+As a nice addition, `yard-junk` command uses its own links to code objects resolver, which is 10x
+faster (and, eventually, more correct) than YARD's own approach to resolve links when rendering docs.
+
+## Usage
+
+It is a `yard-junk` gem, install it as usual, or add to your `Gemfile`.
+
+### Better logs
+
+Add this to your `.yardopts` file:
+```
+--plugin junk
+```
+
+After that, just run `yard` or `yard doc` as usual, and enjoy better logs! You can also setup JunkYard
+logs by passing options (in the same `.yardopts`):
+```
+--junk-log-format FORMAT_STR
+--junk-log-ignore ERROR_TYPE1,ERROR_TYPE2,...
+```
+
+Format is usual Ruby's [#format](https://ruby-doc.org/core-2.2.3/Kernel.html#method-i-format) method
+with named fields:
+* `message` -- error message;
+* `file` -- error file;
+* `line` -- error line;
+* `type` -- error type.
+
+Default format is `%{file}:%{line}: [%{type}] %{message}`, as shown above.
+
+`--junk-log-ignore` option allows to ingore error classes by their type names (shown in logs in `[]`).
+By default, `Undocumentable` error is ignored: it is produced as metaprogramming pieces of code like
+```ruby
+attr_reader *OPTIONS
+```
+or
+```ruby
+include Rails.routes
+```
+...and typically have no way to fix, while polluting logs with a lot of, well, junk.
+
+### Standalone docs check
+
+Just run `yard-junk` command after gem is installed. It should work :)
+
+### Rake task (integrating in CI)
+
+Add this to your `Rakefile`:
+
+```ruby
+require 'yard-junk/rake'
+YardJunk::Rake.task
+```
+
+and then run it (or add to your `.travis.yml`) as
+```
+rake yard:junk
+```
+
+## Reasons
+
+Small problems in docs lead to decrease of readability and usability. But it is hard to check for
+all those problems manually due to YARD's cumbersome output, and lack of CI-ready doc checking tools.
+
+Idea of regularly structured logger was initially [proposed](https://github.com/lsegal/yard/issues/1007)
+as an enchancement for YARD itself, and even some steps were maid by YARD's author in that direction,
+but the idea was abandoned since.
+
+Therefore, this independent tool was made.
+
+## Caveats
+
+* Sometimes YARD doesn't provide enough information to guess in which line of code the problem is;
+  in those cases `junk-yard` just writes something like `file.rb:1` (to stay consistent and not break
+  go-to-file tools);
+* Checking of links to files and URLs proven to be incomplete.
+
+## Roadmap
+
+* Docs for usage as a system-wide YARD plugin;
+* Docs for internals;
+* Colorized output for text reporter;
+* HTML reporter for CIs allowing to store build artifacts;
+* Documentation quality checks as a next level of YARD checker;
+* Option to check new/updated code only (integration with git history)?
+
+## Some examples of problems found in popular gems:
+
+**NB: All of those are excellent libs! The showcase is of "how hard it is to maintain docs quality",
+not of "how ignorant other programmers are".**
+
+httparty:
+```
+lib/httparty/exceptions.rb:2: [UnknownTag] Unknown tag @abstact. Did you mean @abstract?
+lib/httparty/exceptions.rb:20: [MissingParamName] @param tag has empty parameter name
+```
+
+vcr:
+```
+lib/vcr/deprecations.rb:71: [UnknownParam] @param tag has unknown parameter name: name
+lib/vcr/deprecations.rb:73: [UnknownParam] @param tag has unknown parameter name: options
+lib/vcr/linked_cassette.rb:12: [UnknownParam] @param tag has unknown parameter name: context-owned
+lib/vcr/linked_cassette.rb:13: [UnknownParam] @param tag has unknown parameter name: context-unowned
+lib/vcr/linked_cassette.rb:55: [UnknownParam] @param tag has unknown parameter name: context-owned
+lib/vcr/linked_cassette.rb:56: [UnknownParam] @param tag has unknown parameter name: context-unowned
+lib/vcr/test_frameworks/cucumber.rb:27: [UnknownParam] @param tag has unknown parameter name: options
+```
+
+eventmachine:
+```
+lib/em/channel.rb:39: [UnknownParam] @param tag has unknown parameter name: Subscriber
+lib/em/connection.rb:603: [InvalidLink] Cannot resolve link to Socket.unpack_sockaddr_in from text: {Socket.unpack_sockaddr_in}
+lib/em/connection.rb:726: [InvalidLink] Cannot resolve link to EventMachine.notify_readable from text: {EventMachine.notify_readable}
+lib/em/connection.rb:726: [InvalidLink] Cannot resolve link to EventMachine.notify_writable from text: {EventMachine.notify_writable}
+lib/em/connection.rb:739: [InvalidLink] Cannot resolve link to EventMachine.notify_readable from text: {EventMachine.notify_readable}
+lib/em/connection.rb:739: [InvalidLink] Cannot resolve link to EventMachine.notify_writable from text: {EventMachine.notify_writable}
+lib/em/protocols/httpclient2.rb:263: [InvalidLink] Cannot resolve link to |response| from text: {|response| puts response.content }
+lib/em/protocols/httpclient2.rb:276: [InvalidLink] Cannot resolve link to |response| from text: {|response| puts response.content }
+lib/em/protocols/line_protocol.rb:9: [InvalidLink] Cannot resolve link to line from text: {line}
+lib/em/protocols/object_protocol.rb:9: [InvalidLink] Cannot resolve link to 'you from text: {'you said' => obj}
+lib/em/protocols/smtpclient.rb:138: [InvalidLink] Cannot resolve link to "Subject" from text: {"Subject" => "Bogus", "CC" => "<a href="mailto:myboss@example.com">myboss@example.com</a>"}
+lib/em/protocols/smtpclient.rb:138: [InvalidLink] Cannot resolve link to :type=>:plain, from text: {:type=>:plain, :username=>"<a href="mailto:mickey@disney.com">mickey@disney.com</a>", :password=>"mouse"}
+lib/em/protocols/smtpserver.rb:435: [InvalidLink] Cannot resolve link to :cert_chain_file from text: {:cert_chain_file => "/etc/ssl/cert.pem", :private_key_file => "/etc/ssl/private/cert.key"}
+lib/em/protocols/socks4.rb:13: [InvalidLink] Cannot resolve link to data from text: {data}
+lib/em/spawnable.rb:47: [InvalidLink] Cannot resolve link to xxx from text: {xxx}
+lib/eventmachine.rb:215: [InvalidLink] Cannot resolve link to EventMachine.stop from text: {EventMachine.stop}
+lib/eventmachine.rb:231: [InvalidLink] Cannot resolve link to EventMachine::Callback from text: {EventMachine::Callback}
+lib/eventmachine.rb:319: [UnknownParam] @param tag has unknown parameter name: delay
+lib/eventmachine.rb:345: [UnknownParam] @param tag has unknown parameter name: delay
+```
+
+addressable:
+```
+lib/addressable/template.rb:197: [UnknownParam] @param tag has unknown parameter name: *indexes. Did you mean `indexes`?
+lib/addressable/uri.rb:296: [UnknownParam] @param tag has unknown parameter name: *uris. Did you mean `uris`?
+lib/addressable/uri.rb:1842: [UnknownParam] @param tag has unknown parameter name: The
+lib/addressable/uri.rb:1943: [UnknownParam] @param tag has unknown parameter name: The
+lib/addressable/uri.rb:1958: [UnknownParam] @param tag has unknown parameter name: The
+lib/addressable/uri.rb:2023: [UnknownParam] @param tag has unknown parameter name: The
+lib/addressable/uri.rb:2244: [UnknownParam] @param tag has unknown parameter name: *components. Did you mean `components`?
+lib/addressable/uri.rb:2275: [UnknownParam] @param tag has unknown parameter name: *components. Did you mean `components`?
+```
+
+hashie:
+```
+lib/hashie/extensions/coercion.rb:68: [UnknownParam] @param tag has unknown parameter name: key
+lib/hashie/extensions/coercion.rb:69: [UnknownParam] @param tag has unknown parameter name: into
+lib/hashie/extensions/deep_find.rb:7: [InvalidLink] Cannot resolve link to user: from text: {user: {location: {address: '123 Street'}
+lib/hashie/extensions/deep_find.rb:7: [InvalidLink] Cannot resolve link to user: from text: {user: {location: {address: '123 Street'}
+lib/hashie/extensions/deep_find.rb:16: [InvalidLink] Cannot resolve link to location: from text: {location: {address: '123 Street'}
+lib/hashie/extensions/deep_find.rb:16: [InvalidLink] Cannot resolve link to location: from text: {location: {address: '123 Street'}
+lib/hashie/extensions/deep_find.rb:27: [InvalidLink] Cannot resolve link to users: from text: {users: [{location: {address: '123 Street'}
+lib/hashie/extensions/deep_find.rb:27: [InvalidLink] Cannot resolve link to users: from text: {users: [{location: {address: '123 Street'}
+lib/hashie/extensions/deep_find.rb:36: [InvalidLink] Cannot resolve link to location: from text: {location: {address: '123 Street'}
+lib/hashie/extensions/deep_find.rb:36: [InvalidLink] Cannot resolve link to location: from text: {location: {address: '123 Street'}
+lib/hashie/extensions/deep_find.rb:36: [InvalidLink] Cannot resolve link to location: from text: {location: {address: '234 Street'}
+lib/hashie/extensions/deep_find.rb:36: [InvalidLink] Cannot resolve link to location: from text: {location: {address: '234 Street'}
+lib/hashie/extensions/deep_find.rb:36: [InvalidLink] Cannot resolve link to location: from text: {location: {address: '234 Street'}
+lib/hashie/extensions/deep_find.rb:36: [InvalidLink] Cannot resolve link to location: from text: {location: {address: '234 Street'}
+lib/hashie/mash.rb:32: [InvalidLink] Cannot resolve link to :a from text: {:a => {:b => 23, :d => {:e => "abc"}
+lib/hashie/mash.rb:32: [InvalidLink] Cannot resolve link to :g from text: {:g => 44, :h => 29}
+```
+
+## Authors
+
+[Victor Shepelev](https://github.com/zverok)
+
+## License
+
+MIT

data/bin/yard-junk

@@ -0,0 +1,11 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(File.join(File.dirname(File.expand_path(__FILE__)), '..', 'lib'))
+
+require 'yard'
+require 'yard-junk'
+
+janitor = YardJunk::Janitor.new
+janitor.run
+exit janitor.report(YardJunk::Janitor::TextReporter.new(STDOUT))

data/examples/bare_log.rb

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+
+exec('cd examples; yard doc -o doc/ --no-stats input/*.rb')

data/examples/formatted_log.rb

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+exec('cd examples; yard doc -o doc/ --no-stats -e ../lib/junk_yard.rb input/*.rb')
+
+

data/examples/input/circular_ref.rb

@@ -0,0 +1,6 @@
+class Foo
+  # @param (see #b)
+  def a; end
+  # @param (see #a)
+  def b; end
+end

data/examples/input/lot_of_errors.rb

@@ -0,0 +1,42 @@
+# This file tries to show as much errors in documentation as possible
+
+# Macros attached to class
+# @!macro [attach] attached4
+#  $1 $2 $3
+class A
+  # Wrong macro directive format:
+  #
+  # @!macro
+  #
+  # Unknown directive:
+  # @!wtf
+
+
+  # @wrong Free hanging unknown tag
+
+  # Unknown macro name:
+  # @!macro wtf
+  # Points to unknown class: {B}
+  #
+  # @wrong This is unknown tag
+  #
+  # @param arg1 [C] Link to unknown class.
+  # @param arg3 This is unknown argument.
+  #
+  def foo(arg1, arg2)
+  end
+
+  # @param para
+  # @param para
+  # @example
+  # @see {invalid}
+  def bar(para)
+  end
+
+  OPTIONS = %i[foo bar baz]
+  # undocumentable attr_reader
+  attr_reader *OPTIONS
+end
+
+# not recognize namespace
+Bar::BOOKS = 5

data/examples/input/unparseable.rb

@@ -0,0 +1,7 @@
+class
+  def m1
+  end
+end
+
+class B
+end

data/lib/yard-junk/command_line.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module YardJunk
+  module CommandLineOptions
+    def common_options(opts) # rubocop:disable Metrics/MethodLength
+      super
+
+      opts.separator ''
+      opts.separator 'YardJunk plugin options'
+
+      opts.on('--junk-log-format [FMT]', "YardJunk::Logger format string, by default #{Logger::Message::DEFAULT_FORMAT.inspect}") do |format|
+        Logger.instance.format = format
+      end
+
+      opts.on('--junk-log-ignore [TYPE1,TYPE2,...]', "YardJunk::Logger message types to ignore, by default #{Logger::DEFAULT_IGNORE.map(&:inspect).join(', ')}") do |ignore|
+        Logger.instance.ignore = ignore.to_s.split(',')
+      end
+
+      opts.separator ''
+      opts.separator 'Generic options'
+    end
+  end
+end

data/lib/yard-junk/janitor/base_reporter.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module YardJunk
+  class Janitor
+    # This class is a base for reporters that could be passed to
+    # {Janitor#report}.
+    #
+    # Basically, the reporter should define methods:
+    # * `header(title, explanation)` for printing problems section header;
+    # * `row(msg)` for printing instance of {Logger::Message};
+    # * `_stats(**statistics)` for printing statistics.
+    #
+    # Reporter also could redefine `finalize()` method, if it wants to do
+    # something at the end of a report (like "add footer and save to file").
+    #
+    class BaseReporter
+      # @overload initialize(io)
+      #   @param io [#puts] Any IO-alike object that defines `puts` method.
+      #
+      # @overload initialize(filename)
+      #   @param filename [String] Name of file to save the output.
+      def initialize(io_or_filename)
+        @io =
+          case io_or_filename
+          when ->(i) { i.respond_to?(:puts) } # quacks!
+            io_or_filename
+          when String
+            File.open(io_or_filename, 'w')
+          else
+            fail ArgumentError, "Can't create reporter with #{io_or_filename.class}"
+          end
+      end
+
+      def finalize; end
+
+      def section(title, explanation, messages)
+        return if messages.empty?
+        header(title, explanation)
+
+        messages
+          .sort_by { |m| [m.file || '\uFFFF', m.line || 1000, m.message] }
+          .each(&method(:row))
+      end
+
+      def stats(**stat)
+        _stats(stat.merge(duration: humanize_duration(stat[:duration])))
+      end
+
+      private
+
+      def _stats
+        fail NotImplementedError
+      end
+
+      def header(_title, _explanation)
+        fail NotImplementedError
+      end
+
+      def row(_message)
+        fail NotImplementedError
+      end
+
+      def humanize_duration(duration)
+        if duration < 60
+          '%i seconds' % duration
+        else
+          '%.1f minutes' % (duration / 60)
+        end
+      end
+    end
+  end
+end

data/lib/yard-junk/janitor/resolver.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module YardJunk
+  class Janitor
+    # TODO: Tests
+    class Resolver
+      include YARD::Templates::Helpers::HtmlHelper
+
+      MESSAGE_PATTERN = 'In file `%{file}\':%{line}: Cannot resolve link to %{name} from text: %{link}'
+
+      def self.resolve_all(yard_options)
+        YARD::Registry.all.map(&:base_docstring).each { |ds| new(ds, yard_options).resolve }
+      end
+
+      def initialize(docstring, yard_options)
+        @docstring = docstring
+        @options = yard_options
+      end
+
+      def resolve
+        markup_meth = "html_markup_#{options.markup}"
+        return unless respond_to?(markup_meth)
+        send(markup_meth, @docstring)
+          .gsub(%r{<(code|tt|pre)[^>]*>(.*?)</\1>}im, '')
+          .scan(/{[^}]+}/).flatten
+          .map(&CGI.method(:unescapeHTML))
+          .each(&method(:try_resolve))
+      end
+
+      private
+
+      attr_reader :options
+
+      def try_resolve(link)
+        name, _comment = link.tr('{}', '').split(/\s+/, 2)
+        resolved = YARD::Registry.resolve(@docstring.object, name, true, true)
+        return unless resolved.is_a?(YARD::CodeObjects::Proxy)
+        Logger.instance.register(MESSAGE_PATTERN % {file: object.file, line: object.line, name: name, link: link})
+      end
+
+      def object
+        @docstring.object
+      end
+
+      # required by HtmlHelper
+      def serializer
+        nil
+      end
+    end
+  end
+end

data/lib/yard-junk/janitor/text_reporter.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module YardJunk
+  class Janitor
+    # Reporter that just outputs everything in plaintext format. Useful
+    # for commandline usage. See {BaseReporter} for details about reporters.
+    #
+    class TextReporter < BaseReporter
+      private
+
+      def _stats(**stat)
+        line =
+          '%<errors>i failures, %<problems>i problems (%<duration>s to run)' % stat
+        @io.puts "\n#{line}"
+      end
+
+      def header(title, explanation)
+        @io.puts
+        @io.puts title
+        @io.puts '-' * title.length
+        @io.puts explanation + "\n\n"
+      end
+
+      def row(msg)
+        @io.puts msg.to_s # default Message#to_s is good enough
+      end
+    end
+  end
+end

data/lib/yard-junk/janitor.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'benchmark'
+
+module YardJunk
+  class Janitor
+    def run(*opts)
+      YARD::Registry.clear # Somehow loads all Ruby stdlib classes before Rake task started...
+      Logger.instance.format = nil
+
+      puts "Running YardJunk janitor...\n\n"
+
+      @duration = Benchmark.realtime do
+        command = YARD::CLI::Yardoc.new
+        command.run('--no-save', '--no-progress', '--no-stats', '--no-output', *opts)
+        Resolver.resolve_all(command.options)
+      end
+
+      self
+    end
+
+    def stats
+      {
+        errors: errors.count,
+        problems: problems.count,
+        duration: @duration || 0
+      }
+    end
+
+    def report(*reporters)
+      reporters.each do |reporter|
+        reporter.section('Errors', 'severe code or formatting problems', errors)
+        reporter.section('Problems', 'mistyped tags or other typos in documentation', problems)
+
+        reporter.stats(stats)
+        reporter.finalize
+      end
+
+      exit_code
+    end
+
+    def exit_code
+      return 2 unless errors.empty?
+      return 1 unless problems.empty?
+      0
+    end
+
+    private
+
+    def messages
+      YardJunk::Logger.instance.messages.grep_v(Logger::Undocumentable) # FIXME: Not DRY
+    end
+
+    def errors
+      messages.select(&:error?)
+    end
+
+    def problems
+      messages.select(&:warn?)
+    end
+  end
+end
+
+require_relative 'janitor/base_reporter'
+require_relative 'janitor/text_reporter'
+require_relative 'janitor/resolver'

data/lib/yard-junk/logger/message.rb

@@ -0,0 +1,253 @@
+# frozen_string_literal: true
+
+require 'did_you_mean'
+
+module YardJunk
+  class Logger
+    class Message
+      attr_reader :message, :severity, :file, :line, :extra
+
+      def initialize(message:, severity: :warn, code_object: nil, file: nil, line: nil, **extra)
+        @message = message.gsub(/\s{2,}/, ' ')
+        @file = file
+        @line = line&.to_i
+        @code_object = code_object
+        @severity = severity
+        @extra = extra
+      end
+
+      %i[error warn].each do |sev|
+        define_method("#{sev}?") { severity == sev }
+      end
+
+      def to_h
+        {
+          type: type,
+          message: message,
+          file: file,
+          line: line&.to_i || 1
+        }.merge(extra)
+      end
+
+      def ==(other)
+        other.is_a?(self.class) && to_h == other.to_h
+      end
+
+      DEFAULT_FORMAT = '%{file}:%{line}: [%{type}] %{message}'
+
+      def to_s(format = DEFAULT_FORMAT)
+        format % to_h
+      end
+
+      def type
+        self.class.type
+      end
+
+      private
+
+      # DidYouMean changed API dramatically between 1.0 and 1.1, and different rubies have different
+      # versions of it bundled.
+      if DidYouMean.const_defined?(:SpellCheckable)
+        class SpellChecker < Struct.new(:error, :dictionary) # rubocop:disable Style/StructInheritance
+          include DidYouMean::SpellCheckable
+
+          def candidates
+            {error => dictionary}
+          end
+        end
+
+        def spell_check(error, dictionary)
+          SpellChecker.new(error, dictionary).corrections
+        end
+      elsif DidYouMean.const_defined?(:SpellChecker)
+        def spell_check(error, dictionary)
+          DidYouMean::SpellChecker.new(dictionary: dictionary).correct(error)
+        end
+      else
+        def spell_check(*)
+          []
+        end
+      end
+
+      class << self
+        def registry
+          @registry ||= []
+        end
+
+        def pattern(regexp)
+          @pattern = regexp
+          Message.registry << self
+        end
+
+        def search_up(pattern) # rubocop:disable Style/TrivialAccessors
+          @search_up = pattern
+        end
+
+        def try_parse(line, **context)
+          @pattern or fail StandardError, "Pattern is not defined for #{self}"
+          match = @pattern.match(line) or return nil
+          data = context.reject { |_, v| v.nil? }
+                        .merge(match.names.map(&:to_sym).zip(match.captures).to_h.reject { |_, v| v.nil? })
+          data = guard_line(data)
+          new(**data)
+        end
+
+        def type
+          name&.end_with?('::Message') ? 'UnknownError' : name&.sub(/^.+::/, '')
+        end
+
+        def valid_type?(type)
+          type == 'UnknownError' || registry.any? { |m| m.type == type }
+        end
+
+        private
+
+        def guard_line(data) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+          # FIXME: Ugly, huh?
+          data[:file] && data[:line] && @search_up or return data
+          data = data.merge(line: data[:line].to_i)
+          data = data.merge(code_object: find_object(data[:file], data[:line]))
+          lines = File.readlines(data[:file]) rescue (return data) # rubocop:disable Style/RescueModifier
+          pattern = Regexp.new(@search_up % data.map { |k, v| [k, Regexp.escape(v.to_s)] }.to_h)
+          _, num = lines.map
+                        .with_index { |ln, i| [ln, i + 1] }
+                        .first(data[:line]).reverse
+                        .detect { |ln, _| pattern.match(ln) }
+          num or return data
+
+          data.merge(line: num)
+        end
+
+        def find_object(file, line)
+          YARD::Registry.detect { |o| o.file == file && o.line == line }
+        end
+      end
+    end
+
+    class UnknownTag < Message
+      pattern %r{^(?<message>Unknown tag (?<tag>@\S+))( in file `(?<file>[^`]+)` near line (?<line>\d+))?$}
+      search_up '%{tag}(\W|$)'
+
+      def message
+        corrections.empty? ? super : "#{super}. Did you mean #{corrections.map { |c| "@#{c}" }.join(', ')}?"
+      end
+
+      private
+
+      def corrections
+        spell_check(extra[:tag], YARD::Tags::Library.labels.keys.map(&:to_s))
+      end
+    end
+
+    class InvalidTagFormat < Message
+      pattern %r{^(?<message>Invalid tag format for (?<tag>@\S+))( in file `(?<file>[^`]+)` near line (?<line>\d+))?$}
+      search_up '%{tag}(\W|$)'
+    end
+
+    class UnknownDirective < Message
+      pattern %r{^(?<message>Unknown directive (?<directive>@!\S+))( in file `(?<file>[^`]+)` near line (?<line>\d+))?$}
+      search_up '%{directive}(\W|$)'
+
+      # TODO: did_you_mean?
+    end
+
+    class InvalidDirectiveFormat < Message
+      pattern %r{^(?<message>Invalid directive format for (?<directive>@!\S+))( in file `(?<file>[^`]+)` near line (?<line>\d+))?$}
+      search_up '%{directive}(\W|$)'
+    end
+
+    class UnknownParam < Message
+      pattern %r{^(?<message>@param tag has unknown parameter name: (?<param_name>\S+))\s+ in file `(?<file>[^']+)' near line (?<line>\d+)$}
+      search_up '@param(\s+\[.+?\])?\s+?%{param_name}(\W|$)'
+
+      def message
+        corrections.empty? ? super : "#{super}. Did you mean #{corrections.map { |c| "`#{c}`" }.join(', ')}?"
+      end
+
+      private
+
+      def corrections
+        spell_check(extra[:param_name], known_params)
+      end
+
+      def known_params
+        @code_object.is_a?(YARD::CodeObjects::MethodObject) or return []
+        @code_object.parameters.map(&:first).map { |p| p.tr('*&:', '') }
+      end
+    end
+
+    class MissingParamName < Message
+      pattern %r{^(?<message>@param tag has unknown parameter name):\s+in file `(?<file>[^']+)' near line (?<line>\d+)$}
+      search_up '@param(\s+\[.+?\])?\s*$'
+
+      def message
+        '@param tag has empty parameter name'
+      end
+    end
+
+    class DuplicateParam < Message
+      pattern %r{^(?<message>@param tag has duplicate parameter name: (?<param_name>\S+))\s+ in file `(?<file>[^']+)' near line (?<line>\d+)$}
+      search_up '@param\s+(\[.+?\]\s+)?%{param_name}(\W|$)'
+    end
+
+    class RedundantBraces < Message
+      pattern %r{^(?<message>@see tag \(\#\d+\) should not be wrapped in \{\} \(causes rendering issues\)):\s+in file `(?<file>[^']+)' near line (?<line>\d+)$}
+      search_up '@see.*{.*}'
+
+      def message
+        super.sub(/\s+\(\#\d+\)\s+/, ' ')
+      end
+    end
+
+    class SyntaxError < Message
+      pattern %r{^Syntax error in `(?<file>[^`]+)`:\((?<line>\d+),(?:\d+)\): (?<message>.+)$}
+
+      # Honestly, IDK why YARD considers it "warning"... So, rewriting
+      def severity
+        :error
+      end
+    end
+
+    class CircularReference < Message
+      pattern %r{^(?<file>.+?):(?<line>\d+): (?<message>Detected circular reference tag in `(?<object>[^']+)', ignoring all reference tags for this object \((?<context>[^)]+)\)\.)$}
+    end
+
+    class Undocumentable < Message
+      pattern %r{^in (?:\S+): (?<message>Undocumentable (?<object>.+?))\n\s*in file '(?<file>[^']+)':(?<line>\d+):\s+(?:\d+):\s*(?<quote>.+?)\s*$}
+
+      def message
+        super + ": `#{quote}`"
+      end
+
+      def quote
+        extra[:quote]
+      end
+    end
+
+    class UnknownNamespace < Message
+      pattern %r{^(?<message>The proxy (?<namespace>\S+?) has not yet been recognized).\nIf this class/method is part of your source tree, this will affect your documentation results.\nYou can correct this issue by loading the source file for this object before `(?<file>[^']+)'\n$}
+
+      def namespace
+        extra[:namespace]
+      end
+
+      def message
+        "namespace #{namespace} is not recognized"
+      end
+    end
+
+    class MacroAttachError < Message
+      pattern %r{^(?<message>Attaching macros to non-methods is unsupported, ignoring: (?<object>\S+)) \((?<file>.+?):(?<line>\d+)\)$}
+      search_up '@!macro \[attach\]'
+    end
+
+    class MacroNameError < Message
+      pattern %r{^(?<message>Invalid/missing macro name for (?<object>\S+)) \((?<file>.+?):(?<line>\d+)\)$}
+    end
+
+    class InvalidLink < Message
+      pattern %r{^In file `(?<file>[^']+)':(?<line>\d+): (?<message>Cannot resolve link to (?<object>\S+) from text:\s+(?<quote>.+))$}
+      search_up '%{quote}'
+    end
+  end
+end

data/lib/yard-junk/logger.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'singleton'
+require 'pp'
+
+module YardJunk
+  class Logger
+    require_relative 'logger/message'
+
+    include Singleton
+
+    DEFAULT_IGNORE = %w[Undocumentable].freeze
+
+    def messages
+      @messages ||= []
+    end
+
+    def register(msg, severity = :warn)
+      message = Message.registry
+                       .map { |t| t.try_parse(msg, severity: severity, file: @current_parsed_file) }
+                       .compact.first || Message.new(message: msg, file: @current_parsed_file)
+      messages << message
+      puts message.to_s(@format) if output?(message)
+    end
+
+    def notify(msg)
+      case msg
+      when /Parsing (\w\S+)$/
+        # TODO: fragile regexp; cleanup it after everything is parsed.
+        @current_parsed_file = Regexp.last_match(1)
+      when /^Generating/ # end of parsing of any file
+        @current_parsed_file = nil
+      end
+    end
+
+    def clear
+      messages.clear
+      @format = Message::DEFAULT_FORMAT
+      @ignore = DEFAULT_IGNORE
+    end
+
+    def format=(fmt)
+      @format = fmt.to_s
+    end
+
+    def ignore=(list)
+      @ignore = Array(list).map(&:to_s)
+                           .each { |type| Message.valid_type?(type) or fail(ArgumentError, "Unrecognized message type to ignore: #{type}") }
+    end
+
+    private
+
+    def output?(message)
+      !@format.empty? && !@ignore.include?(message.type)
+    end
+
+    module Mixin
+      def debug(msg)
+        YardJunk::Logger.instance.notify(msg)
+        super
+      end
+
+      def warn(msg)
+        YardJunk::Logger.instance.register(msg, :warn)
+      end
+
+      def error(msg)
+        YardJunk::Logger.instance.register(msg, :error)
+      end
+
+      def backtrace(exception, level_meth = :error)
+        super if %i[error fatal].include?(level_meth)
+      end
+    end
+  end
+end
+
+YardJunk::Logger.instance.clear

data/lib/yard-junk/rake.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module YardJunk
+  module Rake
+    extend ::Rake::DSL
+
+    def self.define_task
+      desc 'Check th junk in your YARD Documentation'
+      task('yard:junk') do
+        require 'yard'
+        require_relative '../yard-junk'
+        exit Janitor.new.run.report(Janitor::TextReporter.new(STDOUT))
+      end
+    end
+  end
+end

data/lib/yard-junk.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+require_relative 'yard-junk/logger'
+require_relative 'yard-junk/command_line'
+require_relative 'yard-junk/janitor'
+
+YARD::Logger.prepend YardJunk::Logger::Mixin
+YARD::CLI::Command.prepend YardJunk::CommandLineOptions

data/yard-junk.gemspec

@@ -0,0 +1,48 @@
+Gem::Specification.new do |s|
+  s.name     = 'yard-junk'
+  s.version  = '0.0.1'
+  s.authors  = ['Victor Shepelev']
+  s.email    = 'zverok.offline@gmail.com'
+  s.homepage = 'https://github.com/zverok/junk_yard'
+
+  s.summary = 'Get rid of the junk in your YARD docs'
+  s.description = <<-EOF
+    YardJunk is structured logger/error validator plugin for YARD documentation gem.
+  EOF
+  s.licenses = ['MIT']
+
+  s.required_ruby_version = '>= 2.3.0'
+
+  s.files = `git ls-files`.split($RS).reject do |file|
+    file =~ /^(?:
+    spec\/.*
+    |Gemfile
+    |Rakefile
+    |\.rspec
+    |\.gitignore
+    |\.rubocop.yml
+    |\.travis.yml
+    )$/x
+  end
+  s.require_paths = ["lib"]
+  s.bindir = 'bin'
+  s.executables << 'yard-junk'
+
+  s.add_dependency 'yard'
+  if RUBY_VERSION < '2.4'
+    s.add_dependency 'did_you_mean', '~> 1.0'
+  else
+    s.add_dependency 'did_you_mean', '~> 1.1'
+  end
+
+  s.add_development_dependency 'rubocop', '>= 0.30'
+  s.add_development_dependency 'rspec', '>= 3'
+  s.add_development_dependency 'rubocop-rspec'
+  s.add_development_dependency 'rspec-its', '~> 1'
+  #s.add_development_dependency 'saharspec'
+  s.add_development_dependency 'fakefs'
+  s.add_development_dependency 'simplecov', '~> 0.9'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rubygems-tasks'
+  s.add_development_dependency 'yard'
+end

metadata

@@ -0,0 +1,218 @@
+--- !ruby/object:Gem::Specification
+name: yard-junk
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Victor Shepelev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-08-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: did_you_mean
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.30'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0.30'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: rubocop-rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1'
+- !ruby/object:Gem::Dependency
+  name: fakefs
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubygems-tasks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: "    YardJunk is structured logger/error validator plugin for YARD documentation
+  gem.\n"
+email: zverok.offline@gmail.com
+executables:
+- yard-junk
+extensions: []
+extra_rdoc_files: []
+files:
+- ".rubocop_todo.yml"
+- ".yardopts"
+- README.md
+- bin/yard-junk
+- examples/bare_log.rb
+- examples/formatted_log.rb
+- examples/input/circular_ref.rb
+- examples/input/lot_of_errors.rb
+- examples/input/unparseable.rb
+- lib/yard-junk.rb
+- lib/yard-junk/command_line.rb
+- lib/yard-junk/janitor.rb
+- lib/yard-junk/janitor/base_reporter.rb
+- lib/yard-junk/janitor/resolver.rb
+- lib/yard-junk/janitor/text_reporter.rb
+- lib/yard-junk/logger.rb
+- lib/yard-junk/logger/message.rb
+- lib/yard-junk/rake.rb
+- yard-junk.gemspec
+homepage: https://github.com/zverok/junk_yard
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.3.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.10
+signing_key: 
+specification_version: 4
+summary: Get rid of the junk in your YARD docs
+test_files: []