yard 0.9.26 → 0.9.37

data/CONTRIBUTING.md

@@ -1,140 +0,0 @@
-# Contributing Guide
-
-## Help YARD Help You!
-
-**YARD thrives off of the contributions of its users**. This project will gladly
-review pull requests and issues. This document outlines how to maximize
-the chance of a reported issue being resolved or pull request being accepted.
-
-## Code of Conduct
-
-**All reported issues, pull requests, communication, and code related to YARD**
-**must follow the [Code of Conduct][code] or they will be moderated immediately**.
-Please take time to familiarize yourself with the Code of Conduct before
-you get started. Fundamentally, **you are expected to behave with respect** to all
-other users.
-
-## Filing a Bug Report
-
-**You can submit bug reports on our [GitHub issue tracker][issues]**.
-
-If you believe you have found a bug, please include a few things in your report:
-
-1. **A minimal reproduction of the issue**. Providing a huge blob of code is
-   better than nothing, but providing the shortest possible set of instructions
-   is even better. Take out any instructions or code that, when removed, have
-   no effect on the problematic behavior. The easier your bug is to triage and
-   diagnose, the higher up in the priority list it will go. We can do this stuff,
-   but limited time means this may not happen immediately. Make your bug report
-   extremely accessible and you will almost guarantee a quick fix.
-
-2. **Your environment and relevant versions**. Please include your Ruby,
-   YARD, and system versions (including OS) when reporting a bug. This
-   makes it easier to diagnose problems. If the issue or stack trace
-   includes another library, consider also listing any dependencies
-   that may be affecting the issue. This is where a minimal reproduction
-   case helps a lot.
-
-3. **Your expected result**. Tell us what you think should happen. This
-   helps us to understand the context of your problem. Many complex features
-   can contain ambiguous usage, and your use case may differ from the
-   intended one. If we know your expectations, we can more easily determine
-   if the behavior is intentional or not.
-
-Finally, please **DO NOT** submit a report that states a feature simply
-_"does not work"_ without any additional information in the report. Consider
-the issue from the maintainer's perspective: in order to fix your bug, we
-need to drill down to the broken line of code, and in order to do this,
-we must be able to reproduce the issue on our end to find that line of
-code. The easier we can do this, the quicker your bug gets fixed. Help
-us help you by providing as much information as you possibly can. We may
-not have the tools or environment to properly diagnose your issue, so
-your help may be required to debug the issue.
-
-Also **consider opening a pull request** to fix the issue yourself if you can.
-This will likely speed up the fix time significantly. See below for
-information on how to do this.
-
-## Asking a Question
-
-**Questions are accepted on [GitHub issues][issues], but consider signing up**
-**for the [YARD mailing list][ml]** and asking it there so that we can organize
-issues appropriately. You can also hop onto IRC (irc.freenode.net / #yard)
-for quick questions.
-
-## Asking for a Feature
-
-**YARD does not currently accept feature requests filed as GitHub issues**. If
-you are looking to have a feature implemented into YARD, consider doing this
-yourself and [submitting a pull request][pr] (PR) with your work. If the work
-required is involved, consider starting a discussion on the [mailing list][ml]
-or opening an issue to ask a question; we will be happy to have a conversation
-and let you know if the feature would be considered. They usually are, but
-it might be prudent to ask first!
-
-Please do not fret if your feature request gets closed immediately. We do this
-to keep our issue tracker clean. **Closing an issue does not mean it would not**
-**be accepted as a pull request**. If the feature would not be accepted as a
-PR, this will be communicated in the closed issue.
-
-## Making a Change via Pull Request
-
-**You can also submit pull requests on our [GitHub issue tracker][issues]**.
-
-If you've been working on a patch or feature that you want in YARD, here are
-some tips to ensure the quickest turnaround time on getting it merged in:
-
-1. **Keep your changes small**. If your feature is large, consider splitting
-   it up into smaller portions and submit pull requests for each component
-   individually. Feel free to describe this in your first PR or on the
-   mailing list, but note that it will be much easier to review changes
-   if they affect smaller portions of code at a time.
-
-2. **Keep commits brief and clean**: YARD uses Git and tries to maintain a
-   clean repository. Please ensure that you use [commit conventions][commit]
-   to make things nice and neat both in the description and commit history.
-   Specifically, consider squashing commits if you have partial or complete
-   reverts of code. Each commit should provide an atomic change that moves
-   the project forwards, not back. Any changes that only fix other parts of
-   your PR should be hidden from the commit history.
-
-3. **Follow our coding conventions**. YARD uses typical Ruby source formatting,
-   though it occasionally has minor differences with other projects you may
-   have seen. Please look through a few files (at least the file you are
-   editing) to ensure that you are consistent in the formatting your PR is
-   using.
-
-4. **Make sure you have tests**. Not all changes require tests, but if your
-   changes involve code, you should consider adding at least one new test
-   case for your change (and ideally a couple of tests). This will add
-   confidence when reviewing and will make accepting the change much easier.
-
-5. **Make sure ALL the tests pass**. YARD has a fairly large suite of tests.
-   Please make sure you can run all of the tests (`bundle exec rake`) prior
-   to submitting your PR. Please also remember that YARD supports a number
-   of environments, including OS X, Linux, Windows, and a number of older
-   Ruby versions (1.8+), so if you can test under these environments, that
-   helps (but is not required). At the very least, be aware of this fact
-   when submitting code.
-
-If your change is large, consider starting a discussion on the [mailing list][ml]
-or opening an issue to ask a question; we will be happy to have a conversation
-and let you know if the feature would be considered. They usually are, but
-it might be prudent to ask first!
-
-## Maintainers
-
-**Interested in helping to maintain YARD? Email [lsegal@soen.ca][mail]** for more
-information. Offering to be a project maintainer is an important contribution
-to open source software, and your work will be highly valued in the community.
-If you have been a contributor, consider being a member of the core team to
-help handle day-to-day operations, such as releases, bug fixes, and triage.
-You can do some of this as a non-maintainer too, but if you like this project,
-we can always use more hands on deck!
-
-[code]: https://github.com/lsegal/yard/blob/main/CODE_OF_CONDUCT.md
-[issues]: http://github.com/lsegal/yard/issues
-[commit]: http://chris.beams.io/posts/git-commit/
-[pr]: https://help.github.com/articles/using-pull-requests/
-[ml]: https://groups.google.com/forum/#!forum/yardoc
-[mail]: mailto:lsegal@soen.ca

data/Dockerfile.samus

@@ -1,28 +0,0 @@
-FROM lsegal/samus:latest as samus
-
-FROM ruby:2
-ARG VERSION
-ENV VERSION=${VERSION}
-WORKDIR /github/lsegal/yard
-ENTRYPOINT samus publish release-v${VERSION}.tar.gz
-
-# Prepare credential config
-RUN mkdir -p ~/.ssh
-RUN echo "Host *" > ~/.ssh/config
-RUN echo "    StrictHostKeyChecking no" >> ~/.ssh/config
-RUN chmod 400 ~/.ssh/config
-COPY ./.samusprep/.samus /root/.samus
-COPY ./.samusprep/.gitconfig /root/.gitconfig
-
-# Setup Samus
-ENV PATH=$PATH:/samus/bin
-COPY --from=samus /samus /samus
-
-# Install gems
-ENV BUNDLE_PATH=/var/gems
-COPY Gemfile /github/lsegal/yard
-RUN bundle
-
-# Run build
-COPY . /github/lsegal/yard
-RUN samus build --skip-restore ${VERSION}

data/Gemfile

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-source 'https://rubygems.org'
-
-group :development do
-  gem 'rspec'
-  gem 'rake'
-  gem 'rdoc'
-  gem 'json'
-  gem 'simplecov'
-  gem 'samus', '~> 3.0.9', :require => false
-  gem 'coveralls', :require => false
-  gem 'webrick'
-end
-
-group :asciidoc do
-  gem 'asciidoctor'
-end
-
-group :markdown do
-  gem 'redcarpet'
-end
-
-group :textile do
-  gem 'RedCloth'
-end
-
-group :server do
-  gem 'rack'
-end
-
-group :i18n do
-  gem 'gettext'
-end

data/Rakefile

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-require File.dirname(__FILE__) + '/lib/yard'
-require File.dirname(__FILE__) + '/lib/yard/rubygems/specification'
-require 'rbconfig'
-require 'samus'
-
-YARD::VERSION.replace(ENV['YARD_VERSION']) if ENV['YARD_VERSION']
-
-Dir['tasks/**/*.rake'].each { |task_file| load task_file }
-
-desc "Builds the gem"
-task :gem do
-  sh "gem build yard.gemspec"
-end
-
-desc "Installs the gem"
-task :install => :gem do
-  sh "gem install yard-#{YARD::VERSION}.gem --no-document"
-end
-
-begin
-  require 'rspec/core/rake_task'
-  RSpec::Core::RakeTask.new(:spec)
-rescue LoadError
-  nil # noop
-end
-
-desc "Generate documentation for Yard, and fail if there are any warnings"
-task :test_doc do
-  sh "ruby bin/yard --fail-on-warning #{"--no-progress" if ENV["CI"]}"
-end
-
-task :default => [:spec, :test_doc]
-
-YARD::Rake::YardocTask.new do |t|
-  t.options += ['--title', "YARD #{YARD::VERSION} Documentation"]
-end
-
-Samus::Rake::DockerReleaseTask.new

data/SECURITY.md

@@ -1,26 +0,0 @@
-# Security Policy
-
-## Supported Versions
-
-The following versions are supported with security patches for
-any reported vulnerabilities in YARD or dependent software.
-
-| Version | Supported          |
-| ------- | ------------------ |
-| 0.9.x   | :white_check_mark: |
-| < 0.9   | :x:                |
-
-## Reporting a Vulnerability
-
-If you've discovered a vulnerability in YARD source code, please email
-lsegal@soen.ca with as much information as possible. You should typically
-receive a response within 24-48 hours, though depending on scheduling
-it may take up to a week to respond. If you do not get a response on
-your initial email within a few days, please re-send your email or
-reach out on other channels (such as yardoc@googlegroups.com) to
-try to get a hold of a maintainer. Please do not include sensitive
-material if you are reaching out through secondary channels unless
-you first receive confirmation that it is okay.
-
-Thank you for your help and cooperation in making YARD a stable and
-safe piece of software.

data/benchmarks/builtins_vs_eval.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-require 'benchmark'
-require File.join(File.dirname(__FILE__), '..', 'lib', 'yard')
-
-TIMES = (ARGV[0] || 10_000).to_i
-
-def bench_builtins(name)
-  YARD::CodeObjects::BUILTIN_EXCEPTIONS_HASH.key? name
-end
-
-def bench_eval(name)
-  eval(name).is_a?(Class)
-rescue
-  false
-end
-
-Benchmark.bmbm do |b|
-  b.report("builtins PASS") { TIMES.times { YARD::CodeObjects::BUILTIN_EXCEPTIONS.each {|y| bench_builtins(y) } } }
-  b.report("eval PASS") { TIMES.times { YARD::CodeObjects::BUILTIN_EXCEPTIONS.each {|y| bench_eval(y) } } }
-  b.report("builtins FAIL") { TIMES.times { YARD::CodeObjects::BUILTIN_MODULES.each {|y| bench_builtins(y) } } }
-  b.report("eval FAIL") { TIMES.times { YARD::CodeObjects::BUILTIN_MODULES.each {|y| bench_eval(y) } } }
-  b.report("builtins ANY") { TIMES.times { YARD::CodeObjects::BUILTIN_CLASSES.each {|y| bench_builtins(y) } } }
-  b.report("eval ANY") { TIMES.times { YARD::CodeObjects::BUILTIN_CLASSES.each {|y| bench_eval(y) } } }
-end

data/benchmarks/concat_vs_join.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-require "benchmark"
-
-STR1 = "Hello"
-JOIN = "::"
-STR2 = "World"
-
-TESTS = 100_000
-Benchmark.bmbm do |results|
-  results.report("concat") { TESTS.times { "".concat(STR1).concat(JOIN).concat(STR2) } }
-  results.report("add   ") { TESTS.times { STR1 + JOIN + STR2 } }
-  results.report("join  ") { TESTS.times { [STR1, STR2].join(JOIN) } }
-end

data/benchmarks/erb_vs_erubis.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-require 'rubygems'
-require 'erubis'
-require 'erubis/tiny'
-require 'erb'
-require "benchmark"
-require File.join(File.dirname(__FILE__), '..', 'lib', 'yard')
-
-def rungen
-  YARD::Registry.load_yardoc(File.join(File.dirname(__FILE__), '..', '.yardoc'))
-  YARD::Registry.at("YARD::CodeObjects::Base").format(:format => :html)
-end
-
-Benchmark.bmbm do |x|
-  x.report("erubis") do
-    eval <<-eof
-      module YARD; module Templates; module Template
-        def erb_with(str, x) Erubis::Eruby.new(str) end
-      end end end
-    eof
-
-    rungen
-  end
-
-  x.report("fast-erubis") do
-    eval <<-eof
-      module YARD; module Templates; module Template
-        def erb_with(str, x) Erubis::FastEruby.new(str) end
-      end end end
-    eof
-
-    rungen
-  end
-
-  x.report("tiny-erubis") do
-    eval <<-eof
-      module YARD; module Templates; module Template
-        def erb_with(str, x) Erubis::TinyEruby.new(str) end
-      end end end
-    eof
-
-    rungen
-  end
-
-  x.report("erb") do
-    eval <<-eof
-       module YARD; module Templates; module Template
-        def erb_with(str, x) ERB.new(str) end
-      end end end
-    eof
-
-    rungen
-  end
-end

data/benchmarks/format_args.rb

@@ -1,47 +0,0 @@
-# frozen_string_literal: true
-require "benchmark"
-require 'lib/yard'
-
-def format_args_regex(object)
-  if object.signature
-    object.signature[/#{Regexp.quote object.name.to_s}\s*(.*)/, 1]
-  else
-    ""
-  end
-end
-
-def format_args_parameters(object)
-  if !object.parameters.empty?
-    args = object.parameters.map {|n, v| v ? "#{n} = #{v}" : n.to_s }.join(", ")
-    "(#{args})"
-  else
-    ""
-  end
-end
-
-YARD::Registry.load
-$object = YARD::Registry.at('YARD::Generators::Base#G')
-
-log.puts "regex:  " + format_args_regex($object)
-log.puts "params: " + format_args_parameters($object)
-log.puts
-
-TIMES = 100_000
-Benchmark.bmbm do |x|
-  x.report("regex")      { TIMES.times { format_args_regex($object) } }
-  x.report("parameters") { TIMES.times { format_args_parameters($object) } }
-end
-
-=begin LAST RUN Jun 23 2008
-regex:  (generator, opts = {})
-params: (generator, opts = {})
-
-Rehearsal ----------------------------------------------
-regex        1.270000   0.020000   1.290000 (  1.294558)
-parameters   0.690000   0.000000   0.690000 (  0.693324)
-------------------------------------- total: 1.980000sec
-
-                 user     system      total        real
-regex        1.260000   0.010000   1.270000 (  1.268214)
-parameters   0.670000   0.000000   0.670000 (  0.679114)
-=end

data/benchmarks/generation.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-require "benchmark"
-require File.join(File.dirname(__FILE__), '..', 'lib', 'yard')
-
-unless YARD::CodeObjects::Proxy.private_instance_methods.include?('to_obj')
-  raise "This benchmark is dependent on YARD::CodeObjects::Proxy#to_obj"
-end
-
-def rungen
-  YARD::Registry.clear
-  YARD::CLI::Yardoc.run('--quiet', '--use-cache')
-end
-
-def redef(lock = false)
-  eval <<-eof
-    class YARD::CodeObjects::Proxy;
-      def to_obj
-        @obj #{lock ? '||' : ''}= YARD::Registry.resolve(@namespace, @name)
-      end
-    end
-  eof
-end
-
-Benchmark.bmbm do |x|
-  x.report("gen-w/o-locking")  { redef;       rungen }
-  x.report("gen-with-locking") { redef(true); rungen }
-end
-
-=begin Results from 2008-06-07
-Rehearsal ----------------------------------------------------
-gen-w/o-locking    9.650000   0.450000  10.100000 ( 10.150556)
-gen-with-locking   7.790000   0.400000   8.190000 (  8.373811)
------------------------------------------- total: 18.290000sec
-
-                       user     system      total        real
-gen-w/o-locking    9.820000   0.430000  10.250000 ( 10.293283)
-gen-with-locking   7.820000   0.380000   8.200000 (  8.243326)
-=end

data/benchmarks/marshal_vs_dbm.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-require 'benchmark'
-require 'dbm'
-
-MARSHAL_FILE = "marshal_test.db"
-DBM_FILE = "dbm_test"
-WRITE_TIMES = 1
-READ_TIMES = 100
-NUM_INDICES = 10_000
-INDICES = ['33', '857', '5022', '8555']
-
-def generate_index
-  '0' * (rand * 4096).floor
-end
-
-def write_dbm
-  File.unlink(DBM_FILE + ".db") if File.exist?(DBM_FILE + ".db")
-  handle = DBM.new(DBM_FILE)
-  NUM_INDICES.times {|t| handle[t.to_s] = Marshal.dump(generate_index) }
-  handle.close
-end
-
-def read_dbm
-  db = DBM.open(DBM_FILE)
-  INDICES.each {|index| Marshal.load(db[index]) }
-  db.close
-end
-
-def write_marshal
-  File.unlink(MARSHAL_FILE) if File.exist?(MARSHAL_FILE)
-  handle = {}
-  NUM_INDICES.times {|t| handle[t.to_s] = generate_index }
-  File.open(MARSHAL_FILE, "wb") {|f| f.write(Marshal.dump(handle)) }
-end
-
-def read_marshal
-  db = Marshal.load(File.read(MARSHAL_FILE))
-  INDICES.each {|index| db[index] }
-end
-
-Benchmark.bmbm do |x|
-  x.report("marshal-write") { WRITE_TIMES.times { write_marshal } }
-  x.report("dbm-write") { WRITE_TIMES.times { write_dbm } }
-  x.report("marshal-read ") { READ_TIMES.times { read_marshal } }
-  x.report("dbm-read ") { READ_TIMES.times { read_dbm } }
-end
-
-File.unlink(MARSHAL_FILE)
-File.unlink(DBM_FILE + ".db")
-
-__END__
-
-Rehearsal -------------------------------------------------
-marshal-write   0.090000   0.070000   0.160000 (  0.465820)
-dbm-write       0.560000   0.570000   1.130000 (  3.045556)
-marshal-read    4.640000   3.180000   7.820000 (  7.821978)
-dbm-read        0.020000   0.020000   0.040000 (  0.070920)
----------------------------------------- total: 9.150000sec
-
-                    user     system      total        real
-marshal-write   0.080000   0.050000   0.130000 (  0.436561)
-dbm-write       0.560000   0.550000   1.110000 (  2.030530)
-marshal-read    4.670000   3.180000   7.850000 (  7.842232)
-dbm-read        0.010000   0.020000   0.030000 (  0.053928)

data/benchmarks/parsing.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-require "benchmark"
-require 'yard'
-require 'logger'
-
-PATH_ORDER = [
-  'lib/yard/autoload.rb',
-  'lib/yard/code_objects/base.rb',
-  'lib/yard/code_objects/namespace_object.rb',
-  'lib/yard/handlers/base.rb',
-  'lib/yard/generators/helpers/*.rb',
-  'lib/yard/generators/base.rb',
-  'lib/yard/generators/method_listing_generator.rb',
-  'lib/yard/serializers/base.rb',
-  'lib/**/*.rb'
-]
-
-Benchmark.bmbm do |x|
-  x.report("parse in order") { YARD::Registry.clear; YARD.parse PATH_ORDER, [], Logger::ERROR }
-  x.report("parse") { YARD::Registry.clear; YARD.parse 'lib/**/*.rb', [], Logger::ERROR }
-end
-
-=begin
-load_order branch (2008-06-07):
-
-Rehearsal --------------------------------------------------
-parse in order   6.510000   0.050000   6.560000 (  6.563223)
-parse            6.300000   0.040000   6.340000 (  6.362272)
----------------------------------------- total: 12.900000sec
-
-                     user     system      total        real
-parse in order   6.310000   0.060000   6.370000 (  6.390945)
-parse            6.300000   0.050000   6.350000 (  6.366709)
-
-
-api_changes branch before merge (2008-06-07)
-
-Rehearsal --------------------------------------------------
-parse in order   6.330000   0.050000   6.380000 (  6.397552)
-parse            6.380000   0.050000   6.430000 (  6.446954)
----------------------------------------- total: 12.810000sec
-
-                     user     system      total        real
-parse in order   6.320000   0.040000   6.360000 (  6.394460)
-parse            6.040000   0.040000   6.080000 (  6.099738)
-=end

data/benchmarks/pathname_vs_string.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-require 'pathname'
-require "benchmark"
-require File.dirname(__FILE__) + '/../lib/yard'
-
-pathobj = Pathname.new("a/b/c")
-strobj  = "a/b/c"
-
-TIMES = 1_000
-
-log.puts "join:"
-Benchmark.bmbm do |x|
-  x.report("pathname") { TIMES.times { Pathname.new("a/b/c").join("d", "e", "f") } }
-  x.report("string  ") { TIMES.times { File.join("a/b/c", "d", "e", "f") } }
-  x.report("pathname-sameobject") { TIMES.times { pathobj.join("d", "e", "f") } }
-  x.report("string-sameobject  ") { TIMES.times { File.join(strobj, "d", "e", "f") } }
-end
-
-log.puts
-log.puts
-log.puts "cleanpath:"
-Benchmark.bmbm do |x|
-  x.report("pathname") { TIMES.times { Pathname.new("a/b//.././c").cleanpath } }
-  x.report("string  ") { TIMES.times { File.cleanpath("a/b//.././c") } }
-end
-
-__END__
-join:
-Rehearsal -------------------------------------------------------
-pathname              0.330000   0.020000   0.350000 (  0.353481)
-string                0.010000   0.000000   0.010000 (  0.001390)
-pathname-sameobject   0.360000   0.020000   0.380000 (  0.384473)
-string-sameobject     0.000000   0.000000   0.000000 (  0.001187)
----------------------------------------------- total: 0.740000sec
-
-                          user     system      total        real
-pathname              0.330000   0.020000   0.350000 (  0.350820)
-string                0.000000   0.000000   0.000000 (  0.001055)
-pathname-sameobject   0.330000   0.010000   0.340000 (  0.346949)
-string-sameobject     0.000000   0.000000   0.000000 (  0.001141)
-
-
-cleanpath:
-Rehearsal --------------------------------------------
-pathname   0.060000   0.000000   0.060000 (  0.059767)
-string     0.010000   0.000000   0.010000 (  0.013775)
------------------------------------ total: 0.070000sec
-
-               user     system      total        real
-pathname   0.060000   0.000000   0.060000 (  0.059697)
-string     0.020000   0.000000   0.020000 (  0.013624)

data/benchmarks/rdoc_vs_yardoc.rb

@@ -1,11 +0,0 @@
-# frozen_string_literal: true
-require "benchmark"
-
-files = Dir.glob(File.dirname(__FILE__) + '/../lib/**/*.rb').join(" ")
-Benchmark.bmbm do |x|
-  x.report("rdoc") { `rm -rf rdoc && rdoc -q -o rdoc #{files} && rm -rf rdoc` }
-  x.report("yardoc") { `rm -rf yard && ./bin/yardoc -q -o yard #{files} && rm -rf yard` }
-  x.report("yardoc-cached") { `rm -rf yard && ./bin/yardoc -c -q -o yard #{files} && rm -rf yard` }
-  x.report("yardoc-legacy") { `rm -rf yard && ./bin/yardoc --legacy -q -o yard #{files} && rm -rf yard` }
-  x.report("yardoc-legacy-cached") { `rm -rf yard && ./bin/yardoc --legacy -c -q -o yard #{files} && rm -rf yard` }
-end

data/benchmarks/registry_store_types.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-require 'benchmark'
-require File.join(File.dirname(__FILE__), '..', 'lib', 'yard')
-
-def parse_and_select_objects
-  YARD::Registry.load_yardoc(File.join(File.dirname(__FILE__), '..', '.yardoc'))
-  YARD::Registry.load_all
-  $paths = []
-  4.times { $paths << YARD::Registry.paths[rand(YARD::Registry.paths.size)] }
-
-  $regular_registry = {}
-  $types_registry = {}
-  YARD::Registry.all.each do |object|
-    $regular_registry[object.path] = object
-    ($types_registry[object.type] ||= {})[object.path] = object
-  end
-end
-
-def run_lookup
-  $paths.select {|path| $regular_registry[path] }
-end
-
-def run_lookup_with_types
-  $paths.select {|path| $types_registry.values.find {|list| list[path] } }
-end
-
-TIMES = 100_000
-
-parse_and_select_objects
-p $paths
-Benchmark.bmbm do |x|
-  x.report("normal") { TIMES.times { run_lookup } }
-  x.report("types")  { TIMES.times { run_lookup_with_types } }
-end
-
-__END__
-# Run on March 22 2012
-["YARD::Parser::Ruby::Legacy::RubyToken::TkUnknownChar#initialize",
-  "YARD::Parser::C::CParser#enumerator",
-  "YARD::CodeObjects::ClassObject#inherited_meths",
-  "YARD::Parser::C::Statement#source="]
-Rehearsal ----------------------------------------------
-normal       0.180000   0.000000   0.180000 (  0.182640)
-types        1.150000   0.010000   1.160000 (  1.160219)
-------------------------------------- total: 1.340000sec
-
-                 user     system      total        real
-normal       0.170000   0.000000   0.170000 (  0.165621)
-types        1.140000   0.000000   1.140000 (  1.142269)