climine 0.0.1

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

@@ -0,0 +1,23 @@
+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.0.0/gems/yard-0.8.7.3/benchmarks/concat_vs_join.rb

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

@@ -0,0 +1,53 @@
+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.0.0/gems/yard-0.8.7.3/benchmarks/format_args.rb

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

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

@@ -0,0 +1,63 @@
+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.0.0/gems/yard-0.8.7.3/benchmarks/parsing.rb

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

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

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

@@ -0,0 +1,48 @@
+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.0.0/gems/yard-0.8.7.3/benchmarks/ri_vs_yri.rb

@@ -0,0 +1,18 @@
+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.0.0/gems/yard-0.8.7.3/benchmarks/ripper_parser.rb

@@ -0,0 +1,12 @@
+# 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.0.0/gems/yard-0.8.7.3/benchmarks/splat_vs_flatten.rb

@@ -0,0 +1,12 @@
+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.0.0/gems/yard-0.8.7.3/benchmarks/template_erb.rb

@@ -0,0 +1,22 @@
+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.0.0/gems/yard-0.8.7.3/benchmarks/template_format.rb

@@ -0,0 +1,6 @@
+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.0.0/gems/yard-0.8.7.3/benchmarks/template_profile.rb

@@ -0,0 +1,17 @@
+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.0.0/gems/yard-0.8.7.3/benchmarks/yri_cache.rb

@@ -0,0 +1,19 @@
+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.0.0/gems/yard-0.8.7.3/bin/yard

@@ -0,0 +1,12 @@
+#!/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.0.0/gems/yard-0.8.7.3/bin/yardoc

@@ -0,0 +1,12 @@
+#!/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.0.0/gems/yard-0.8.7.3/bin/yri

@@ -0,0 +1,12 @@
+#!/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.0.0/gems/yard-0.8.7.3/docs/CodeObjects.md

@@ -0,0 +1,115 @@
+# @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.