climine 0.0.7 → 0.0.8

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/benchmarks/builtins_vs_eval.rb

@@ -1,23 +0,0 @@
-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.has_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/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/benchmarks/concat_vs_join.rb

@@ -1,12 +0,0 @@
-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/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/benchmarks/erb_vs_erubis.rb

@@ -1,53 +0,0 @@
-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, nil) end
-      end end end
-    eof
-
-    rungen
-  end
-end

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/benchmarks/format_args.rb

@@ -1,46 +0,0 @@
-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/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/benchmarks/generation.rb

@@ -1,37 +0,0 @@
-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/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/benchmarks/marshal_vs_dbm.rb

@@ -1,63 +0,0 @@
-require 'benchmark'
-require 'dbm'
-
-MARSHAL_FILE = "marshal_test.db"
-DBM_FILE = "dbm_test"
-WRITE_TIMES = 1
-READ_TIMES = 100
-NUM_INDICES = 10000
-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/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/benchmarks/parsing.rb

@@ -1,46 +0,0 @@
-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/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/benchmarks/pathname_vs_string.rb

@@ -1,50 +0,0 @@
-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/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/benchmarks/rdoc_vs_yardoc.rb

@@ -1,10 +0,0 @@
-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/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/benchmarks/registry_store_types.rb

@@ -1,48 +0,0 @@
-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)

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/benchmarks/ri_vs_yri.rb

@@ -1,18 +0,0 @@
-require "benchmark"
-
-TIMES = 10
-Benchmark.bmbm do |x|
-  x.report("ri") { TIMES.times { `ri -T YARD::Tags::Library` } }
-  x.report("yri") { TIMES.times { `./bin/yri -T YARD::Tags::Library` } }
-end
-
-__END__
-
-Rehearsal ---------------------------------------
-ri    0.000000   0.020000   6.880000 (  6.929591)
-yri   0.000000   0.000000   1.060000 (  1.074840)
------------------------------- total: 7.940000sec
-
-          user     system      total        real
-ri    0.000000   0.020000   6.850000 (  6.871660)
-yri   0.000000   0.010000   1.060000 (  1.067585)

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/benchmarks/ripper_parser.rb

@@ -1,12 +0,0 @@
-# encoding: utf-8
-require 'benchmark'
-require File.dirname(__FILE__) + '/../lib/yard'
-
-$files = Dir[File.dirname(__FILE__) + '/../lib/**/*.rb'].map {|f| File.read(f) }
-$files_rip = Dir[File.dirname(__FILE__) + '/../lib/**/*.rb'].map {|f| [File.read(f), f] }
-
-TIMES = 2
-Benchmark.bmbm do |x|
-  x.report("rip-parser") { TIMES.times { $files_rip.each {|f| YARD::Parser::Ruby::RubyParser.parse(*f) } } }
-  x.report("yard-parser  ") { TIMES.times { $files.each {|f| YARD::Parser::Ruby::Legacy::StatementList.new(f) } } }
-end

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/benchmarks/splat_vs_flatten.rb

@@ -1,12 +0,0 @@
-require "benchmark"
-
-# To prove that flattening a small list is not significantly slower than
-# calling *list (used to get around create_tag list issue)
-$a = "FOO BAR BAZ"
-def foo(*args) args.last.inspect end
-
-TESTS = 10_000
-Benchmark.bmbm do |x|
-  x.report("splat") { TESTS.times { foo *$a } }
-  x.report("flatten") { TESTS.times { foo *[$a].flatten } }
-end

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/benchmarks/template_erb.rb

@@ -1,22 +0,0 @@
-require "benchmark"
-require File.join(File.dirname(__FILE__), '..', 'lib', 'yard')
-
-YARD::Registry.load_yardoc(File.join(File.dirname(__FILE__), '..', '.yardoc'))
-obj = YARD::Registry.at("YARD::CodeObjects::Base")
-
-TIMES = 3
-Benchmark.bm do |x|
-  x.report("trim-line") { TIMES.times { obj.format(:format => :html) } }
-  module YARD
-    module Templates
-      module Template
-        def erb(section, &block)
-          erb = ERB.new(cache(section), nil)
-          erb.filename = cache_filename(section).to_s
-          erb.result(binding, &block)
-        end
-      end
-    end
-  end
-  x.report("no-trim  ") { TIMES.times { obj.format(:format => :html) } }
-end

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/benchmarks/template_format.rb

@@ -1,6 +0,0 @@
-require "benchmark"
-require File.join(File.dirname(__FILE__), '..', 'lib', 'yard')
-
-YARD::Registry.load_yardoc(File.join(File.dirname(__FILE__), '..', '.yardoc'))
-obj = YARD::Registry.at("YARD::CodeObjects::Base")
-log.puts Benchmark.measure { obj.format(:format => :html) }

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/benchmarks/template_profile.rb

@@ -1,17 +0,0 @@
-require 'rubygems'
-require 'ruby-prof'
-#require 'benchmark'
-require File.join(File.dirname(__FILE__), '..', 'lib', 'yard')
-
-YARD::Registry.load_yardoc(File.join(File.dirname(__FILE__), '..', '.yardoc'))
-obj = YARD::Registry.at("YARD::CodeObjects::Base")
-
-#PerfTools::CpuProfiler.start("template_profile") do
-#end
-
-result = RubyProf.profile do
-  obj.format(:format => :html, :no_highlight => true)
-end
-
-printer = RubyProf::CallTreePrinter.new(result)
-printer.print(STDOUT)

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/benchmarks/yri_cache.rb

@@ -1,19 +0,0 @@
-require File.dirname(__FILE__) + "/../lib/yard"
-require "benchmark"
-include YARD::CLI
-
-class YARD::CLI::YRI
-  def print_object(object) end
-end
-
-def remove_cache
-  File.unlink(YRI::CACHE_FILE)
-end
-
-TIMES = 10
-NAME = 'YARD'
-remove_cache; YRI.run(NAME)
-Benchmark.bmbm do |x|
-  x.report("cache   ") { TIMES.times { YRI.run(NAME) } }
-  x.report("no-cache") { TIMES.times { remove_cache; YRI.run(NAME) } }
-end

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/bin/yard

@@ -1,12 +0,0 @@
-#!/usr/bin/env ruby
-
-# We do all this work just to find the proper load path
-path = __FILE__
-while File.symlink?(path)
-  path = File.expand_path(File.readlink(path), File.dirname(path))
-end
-$:.unshift(File.join(File.dirname(File.expand_path(path)), '..', 'lib'))
-
-require 'yard'
-
-YARD::CLI::CommandParser.run(*ARGV)

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/bin/yardoc

@@ -1,12 +0,0 @@
-#!/usr/bin/env ruby
-
-# We do all this work just to find the proper load path
-path = __FILE__
-while File.symlink?(path)
-  path = File.expand_path(File.readlink(path), File.dirname(path))
-end
-$:.unshift(File.join(File.dirname(File.expand_path(path)), '..', 'lib'))
-
-require 'yard'
-
-YARD::CLI::Yardoc.run(*ARGV)

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/bin/yri

@@ -1,12 +0,0 @@
-#!/usr/bin/env ruby
-
-# We do all this work just to find the proper load path
-path = __FILE__
-while File.symlink?(path)
-  path = File.expand_path(File.readlink(path), File.dirname(path))
-end
-$:.unshift(File.join(File.dirname(File.expand_path(path)), '..', 'lib'))
-
-require 'yard'
-
-YARD::CLI::YRI.run(*ARGV)

data/vendor/bundle/ruby/2.1.0/gems/yard-0.8.7.3/docs/CodeObjects.md

@@ -1,115 +0,0 @@
-# @title CodeObjects Architecture
-
-# CodeObjects Architecture
-
-Code objects are Ruby objects that describe the code being documented. For instance,
-all classes, modules, methods, etc. are all extracted from the Ruby source as code
-objects. All of these code objects extend from the {YARD::CodeObjects::Base} class, which
-provides basic attributes like source location, source code, name and path.
-
-## CodeObjects Organization
-
-Code objects are divided into two basic types. {YARD::CodeObjects::NamespaceObject NamespaceObjects}
-and non-namespace objects. A namespace object refers to any object in Ruby that can have
-other objects defined inside of it. In the context of Ruby, this specifically means
-modules and classes (both of which are subclasses of `NamespaceObject`). These objects
-act like tree structures, maintaining a list of all of their direct children. All non
-namespace objects are simply subclasses of the Base class. The {YARD::CodeObjects::RootObject RootObject}
-is a special kind of `NamespaceObject` which refers to the top level namespace in Ruby.
-Methods that accept a namespace object as a parameter should also accept the symbol
-`:root` as a shortcut for the root object.
-
-The following is an overview of the classes within the `CodeObjects` namespace:
-
-![CodeObjects Class Diagram](images/code-objects-class-diagram.png)
-
-## Unique Path Representation
-
-All CodeObjects are uniquely defined by their implementation of {YARD::CodeObjects::Base#path}.
-This path is used to locate or store a code object in the {YARD::Registry}. It is therefore
-essential that any Base subclass return a unique String value for #path so that the
-object may co-exist with other objects in the Registry.
-
-In practice, a path is simply the conventional Ruby representation of a class,
-module, constant, class variable or method. For example, the following objects
-would have the following respective paths:
-
-* Class `Klass` inside module `Mod`: `Mod::Klass`
-* Instance method `bar` inside class `Foo`: `Foo#bar`
-* Class method `bar` inside class `Foo`: `Foo.bar`
-* Constant `VERSION` inside class `YARD`: `YARD::VERSION`
-* Class variable `@@abc` inside class `A`: `A::@@abc`
-
-## Registry
-
-CodeObjects classes are coupled with the {YARD::Registry} class which keeps track of
-all instantiated code objects. This is an explicit design choice to allow objects
-to be fetched, cached, imported and exported from a centralized location. As mentioned
-above, this coupling is a result of the fact that each object is uniquely identified by
-its path, which is used to implement lookups. You can read more about the registry
-in the {YARD::Registry} class.
-
-## Identity Map
-
-Code objects are instantiated using an identity-map like implementation that guarantees
-only one unique Ruby object exists for an object described by a specific path. This
-allows developers to create a code object without checking if it already exists in
-the {YARD::Registry}. The following example will only create one object:
-
-    id = ClassObject.new(:root, "MyClass").object_id #=> 13352
-    ClassObject.new(:root, "MyClass").object_id #=> 13352
-
-## Proxy Objects
-
-In addition to providing access to existing objects, a {YARD::CodeObjects::Proxy}
-class exists which can represent an object at a path that may or may not have been
-created. This is necessary to represent a reference to an object in code that is
-never defined in the same body of source code, or perhaps defined later. If any
-attributes of a proxy are accessed, it will immediately be resolved to the object
-at its declared path. In the case where such an object exists, it will act as
-a delegate to the object. However, if the object does not exist, a warning will
-be raised. Whenever arbitrary code objects are used, care should be taken in
-order to make sure attributes are not accessed on unresolvable proxies. An
-unresolvable proxy will return a class name of `Proxy` and #type of `:proxy`,
-for example:
-
-    P(:InvalidObject).type == :proxy  #=> true
-    P(:InvalidObject).is_a?(Proxy)    #=> true
-
-## Adding Data to Code Objects
-
-Code objects act as hash-like structures that allow any arbitrary value to be set.
-This allows easy extending of existing objects without creating custom subclasses.
-For instance, to add a timestamp to a method object (when it was modified, maybe),
-it is possible to simply do:
-
-    object = MethodObject.new(:root, "my_method")
-    object[:modified_at] = Time.now
-
-This value can now be retrieved on this object both by the hash `[]` syntax as
-well as like any other method:
-
-    object.modified_at #=> 2009-06-03 20:08:46 -0400
-
-## Creating a Custom CodeObject
-
-It should first be mentioned that creating a custom code object should not be
-necessary in most cases, except when functionality that cannot be represented
-by classical Ruby objects is added. A good example *might* be a test class,
-which although is technically a Ruby class, has a significantly different purpose
-in documentation and needs a different set of metadata, as well as its own
-representation in documentation.
-
-The {YARD::CodeObjects::Base#path} implementation is the most important part of the
-code object architecture. The first thing any custom code object must guarantee is
-that its path value is unique among all other objects. The recommended way to do this
-with custom objects is to add a descriptive prefix to the path. For example, the
-following is an implementation of the path for a hypothetical `FooObject`:
-
-    def path
-      "__FooPrefix" + sep + super
-    end
-
-Note that if our FooObject is a `NamespaceObject`, meaning if it can have child
-FooObjects defined inside of it, you may need to verify that the prefix is only
-applied once.