Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse files

Update docs

  • Loading branch information...
commit 8b68be47fdc09076c11a2c414169393547f7f93f 1 parent e28f0e6
@lsegal authored
Showing with 12,541 additions and 5,953 deletions.
  1. +98 −14 doc/Array.html
  2. +0 −145 doc/CODE_OBJECTS.markdown.html
  3. +0 −54 doc/FAQ.markdown.html
  4. +25 −25 doc/File.html
  5. +0 −239 doc/GENERATORS.markdown.html
  6. +0 −295 doc/GETTING_STARTED.markdown.html
  7. +0 −37 doc/GLOSSARY.markdown.html
  8. +55 −46 doc/Gem/DocManager.html
  9. +20 −15 doc/Gem/Specification.html
  10. +214 −22 doc/Insertion.html
  11. +0 −50 doc/LICENSE.html
  12. +103 −22 doc/Module.html
  13. +0 −247 doc/README.markdown.html
  14. +108 −22 doc/String.html
  15. +585 −86 doc/SymbolHash.html
  16. +35 −30 doc/YARD.html
  17. +20 −11 doc/YARD/CLI.html
  18. +189 −120 doc/YARD/CLI/YardGraph.html
  19. +422 −205 doc/YARD/CLI/Yardoc.html
  20. +93 −81 doc/YARD/CodeObjects.html
  21. +1,320 −396 doc/YARD/CodeObjects/Base.html
  22. +552 −145 doc/YARD/CodeObjects/ClassObject.html
  23. +29 −19 doc/YARD/CodeObjects/ClassVariableObject.html
  24. +155 −39 doc/YARD/CodeObjects/CodeObjectList.html
  25. +73 −45 doc/YARD/CodeObjects/ConstantObject.html
  26. +155 −26 doc/YARD/CodeObjects/ExtendedMethodObject.html
  27. +561 −157 doc/YARD/CodeObjects/MethodObject.html
  28. +107 −34 doc/YARD/CodeObjects/ModuleObject.html
  29. +939 −336 doc/YARD/CodeObjects/NamespaceObject.html
  30. +719 −312 doc/YARD/CodeObjects/Proxy.html
  31. +24 −18 doc/YARD/CodeObjects/ProxyMethodError.html
  32. +51 −31 doc/YARD/CodeObjects/RootObject.html
  33. +453 −198 doc/YARD/Docstring.html
  34. +22 −11 doc/YARD/Handlers.html
  35. +248 −128 doc/YARD/Handlers/Base.html
  36. +117 −55 doc/YARD/Handlers/NamespaceMissingError.html
  37. +529 −167 doc/YARD/Handlers/Processor.html
  38. +10 −11 doc/YARD/Handlers/Ruby.html
  39. +33 −22 doc/YARD/Handlers/Ruby/AliasHandler.html
  40. +32 −20 doc/YARD/Handlers/Ruby/AttributeHandler.html
  41. +48 −23 doc/YARD/Handlers/Ruby/Base.html
  42. +40 −22 doc/YARD/Handlers/Ruby/ClassConditionHandler.html
  43. +40 −22 doc/YARD/Handlers/Ruby/ClassHandler.html
  44. +40 −22 doc/YARD/Handlers/Ruby/ClassVariableHandler.html
  45. +40 −22 doc/YARD/Handlers/Ruby/ConstantHandler.html
  46. +40 −22 doc/YARD/Handlers/Ruby/ExceptionHandler.html
  47. +46 −26 doc/YARD/Handlers/Ruby/ExtendHandler.html
  48. +82 −45 doc/YARD/Handlers/Ruby/HandlesExtension.html
  49. +21 −12 doc/YARD/Handlers/Ruby/Legacy.html
  50. +41 −24 doc/YARD/Handlers/Ruby/Legacy/AliasHandler.html
  51. +40 −22 doc/YARD/Handlers/Ruby/Legacy/AttributeHandler.html
  52. +42 −20 doc/YARD/Handlers/Ruby/Legacy/Base.html
  53. +43 −22 doc/YARD/Handlers/Ruby/Legacy/ClassHandler.html
  54. +49 −28 doc/YARD/Handlers/Ruby/Legacy/ClassVariableHandler.html
  55. +49 −28 doc/YARD/Handlers/Ruby/Legacy/ConstantHandler.html
  56. +43 −22 doc/YARD/Handlers/Ruby/Legacy/ExceptionHandler.html
  57. +49 −26 doc/YARD/Handlers/Ruby/Legacy/ExtendHandler.html
  58. +64 −23 doc/YARD/Handlers/Ruby/Legacy/MethodHandler.html
  59. +47 −22 doc/YARD/Handlers/Ruby/Legacy/MixinHandler.html
  60. +43 −22 doc/YARD/Handlers/Ruby/Legacy/ModuleHandler.html
  61. +43 −22 doc/YARD/Handlers/Ruby/Legacy/VisibilityHandler.html
  62. +43 −22 doc/YARD/Handlers/Ruby/Legacy/YieldHandler.html
  63. +21 −20 doc/YARD/Handlers/Ruby/MethodCallWrapper.html
  64. +40 −22 doc/YARD/Handlers/Ruby/MethodConditionHandler.html
  65. +86 −44 doc/YARD/Handlers/Ruby/MethodHandler.html
  66. +44 −22 doc/YARD/Handlers/Ruby/MixinHandler.html
  67. +40 −22 doc/YARD/Handlers/Ruby/ModuleHandler.html
  68. +21 −20 doc/YARD/Handlers/Ruby/TestNodeWrapper.html
  69. +40 −22 doc/YARD/Handlers/Ruby/VisibilityHandler.html
  70. +40 −22 doc/YARD/Handlers/Ruby/YieldHandler.html
  71. +218 −55 doc/YARD/Logger.html
  72. +21 −11 doc/YARD/Parser.html
  73. +32 −18 doc/YARD/Parser/LoadOrderError.html
  74. +29 −20 doc/YARD/Parser/ParserSyntaxError.html
  75. +217 −32 doc/YARD/Parser/Ruby.html
  76. +1,315 −323 doc/YARD/Parser/Ruby/AstNode.html
  77. +52 −37 doc/YARD/Parser/Ruby/ConditionalNode.html
  78. +21 −12 doc/YARD/Parser/Ruby/Legacy.html
  79. +241 −166 doc/YARD/Parser/Ruby/Legacy/RubyLex.html
  80. +109 −62 doc/YARD/Parser/Ruby/Legacy/RubyLex/BufferedReader.html
  81. +79 −74 doc/YARD/Parser/Ruby/Legacy/RubyToken.html
  82. +25 −19 doc/YARD/Parser/Ruby/Legacy/RubyToken/TkBlockContents.html
  83. +22 −18 doc/YARD/Parser/Ruby/Legacy/RubyToken/TkError.html
  84. +95 −54 doc/YARD/Parser/Ruby/Legacy/RubyToken/TkId.html
  85. +27 −20 doc/YARD/Parser/Ruby/Legacy/RubyToken/TkKW.html
  86. +30 −27 doc/YARD/Parser/Ruby/Legacy/RubyToken/TkNode.html
  87. +98 −58 doc/YARD/Parser/Ruby/Legacy/RubyToken/TkOPASGN.html
  88. +29 −19 doc/YARD/Parser/Ruby/Legacy/RubyToken/TkOp.html
  89. +25 −19 doc/YARD/Parser/Ruby/Legacy/RubyToken/TkStatementEnd.html
  90. +91 −54 doc/YARD/Parser/Ruby/Legacy/RubyToken/TkUnknownChar.html
  91. +59 −21 doc/YARD/Parser/Ruby/Legacy/RubyToken/TkVal.html
  92. +22 −18 doc/YARD/Parser/Ruby/Legacy/RubyToken/TkWhitespace.html
  93. +104 −70 doc/YARD/Parser/Ruby/Legacy/RubyToken/Token.html
  94. +100 −63 doc/YARD/Parser/Ruby/Legacy/Statement.html
  95. +59 −34 doc/YARD/Parser/Ruby/Legacy/StatementList.html
Sorry, we could not display the entire diff because it was too big.
View
112 doc/Array.html
@@ -1,6 +1,6 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<meta name="Content-Type" content="text/html; charset=UTF-8" />
<title>Class: Array</title>
@@ -12,23 +12,22 @@
if (relpath != '') relpath += '/';
</script>
<script type="text/javascript" charset="utf-8" src="js/jquery.js"></script>
- <script type="text/javascript" charset="utf-8" src="js/autocomplete.js"></script>
<script type="text/javascript" charset="utf-8" src="js/app.js"></script>
</head>
<body>
<div id="header">
<div id="menu">
- <a href="glossary.html">Glossary (A)</a> ::
+ <a href="_index.html">Index (A)</a> &raquo;
- Array
+ <span class="title">Array</span>
</div>
<div id="search">
- <a id="class_list_link" href="#">Namespace List</a> |
- <a id="method_list_link" href="#">Method List</a> |
+ <a id="class_list_link" href="#">Namespace List</a>
+ <a id="method_list_link" href="#">Method List</a>
<a id ="file_list_link" href="#">File List</a>
</div>
<div class="clear"></div>
@@ -58,13 +57,22 @@
</dl>
<div class="clear"></div>
+<div id="subclasses">
+ <h2>Direct Known Subclasses</h2>
+ <p class="children"><a href="YARD/CodeObjects/CodeObjectList.html" title="YARD::CodeObjects::CodeObjectList">YARD::CodeObjects::CodeObjectList</a>, <a href="YARD/Parser/Ruby/AstNode.html" title="YARD::Parser::Ruby::AstNode">YARD::Parser::Ruby::AstNode</a>, <a href="YARD/Parser/Ruby/Legacy/StatementList.html" title="YARD::Parser::Ruby::Legacy::StatementList">YARD::Parser::Ruby::Legacy::StatementList</a>, <a href="YARD/Parser/Ruby/Legacy/TokenList.html" title="YARD::Parser::Ruby::Legacy::TokenList">YARD::Parser::Ruby::Legacy::TokenList</a></p>
+</div>
<h2>Method Summary</h2>
<ul class="summary">
<li class="public ">
- <a href="#place-instance_method" title="- (Object) place(a) ">- (Object) place(a) </a>
+ <a href="#place-instance_method" title="- (Insertion) place(value) ">- (Insertion) place(value) </a>
+
+ <span class="summary_desc">
+Places a value before or after another object (by value) in.
+
+</span>
</li>
@@ -75,22 +83,98 @@
<div class="method_details">
<p class="signature first" id="place-instance_method">
- - (Object) place(a)
+ - (<tt><a href="Insertion.html" title="Insertion">Insertion</a></tt>) place(value)
+
+
+
+</p><div class="docstring">
+ <div class="discussion">
+ <p>
+Places a value before or after another object (by value) in an array. This
+is used in tandem with the before and after methods of the <tt><a href="Insertion.html" title="Insertion">Insertion</a></tt>
+class.
+</p>
+
+ </div>
+</div>
+<div class="tags">
+ <div class="examples">
+ <h3>Examples:</h3>
+
+ <h4>
+Places an item before another
+
+</h4>
+ <pre class="example code"> <span class='lbracket'>[</span><span class='int'>1</span><span class='comma'>,</span> <span class='int'>2</span><span class='comma'>,</span> <span class='int'>3</span><span class='rbracket'>]</span><span class='period'>.</span><span class='id place'>place</span><span class='lparen'>(</span><span class='int'>4</span><span class='rparen'>)</span><span class='period'>.</span><span class='id before'>before</span><span class='lparen'>(</span><span class='int'>3</span><span class='rparen'>)</span> <span class='comment'># =&gt; [1, 2, 4, 3]</span></pre>
+
+ <h4>
+Places an item after another
+
+</h4>
+ <pre class="example code"> <span class='lbracket'>[</span><span class='symbol'>:a</span><span class='comma'>,</span> <span class='symbol'>:b</span><span class='comma'>,</span> <span class='symbol'>:c</span><span class='rbracket'>]</span><span class='period'>.</span><span class='id place'>place</span><span class='lparen'>(</span><span class='symbol'>:x</span><span class='rparen'>)</span><span class='period'>.</span><span class='id after'>after</span><span class='lparen'>(</span><span class='symbol'>:a</span><span class='rparen'>)</span> <span class='comment'># =&gt; [:a, :x, :b, :c]</span></pre>
+
+ </div>
+<h3>Parameters:</h3>
+<ul class="param">
+
+ <li>
+
+ <span class='type'>(<tt>Object</tt>)</span>
+
+
+ <span class='name'>value</span>
+
+
+
+ &mdash;
+
+value to insert
+
+
+
+ </li>
+
+</ul>
+<h3>Returns:</h3>
+<ul class="return">
+ <li>
+
+ <span class='type'>(<tt><a href="Insertion.html" title="Insertion">Insertion</a></tt>)</span>
+
+
+
+
+ &mdash;
+
+an insertion object to
+
+
+ </li>
-</p><table class="source_code">
+</ul>
+ <h3>See Also:</h3>
+ <ul class="see">
+
+ <li><a href="Insertion.html#before-instance_method" title="Insertion#before">Insertion#before</a></li>
+
+ <li><a href="Insertion.html#after-instance_method" title="Insertion#after">Insertion#after</a></li>
+
+ </ul>
+
+</div><table class="source_code">
<tr>
<td>
<pre class="lines">
-2</pre>
+14</pre>
</td>
<td>
- <pre class="code"><span class="info file"># File 'lib/yard/core_ext/array.rb', line 2</span>
+ <pre class="code"><span class="info file"># File 'lib/yard/core_ext/array.rb', line 14</span>
-<span class='kw'>def</span> <span class='id place'>place</span><span class='lparen'>(</span><span class='id a'>a</span><span class='rparen'>)</span> <span class='const'>Insertion</span><span class='period'>.</span><span class='id new'>new</span><span class='lparen'>(</span><span class='kw'>self</span><span class='comma'>,</span> <span class='id a'>a</span><span class='rparen'>)</span> <span class='kw'>end</span></pre>
+<span class='kw'>def</span> <span class='id place'>place</span><span class='lparen'>(</span><span class='id value'>value</span><span class='rparen'>)</span> <span class='const'>Insertion</span><span class='period'>.</span><span class='id new'>new</span><span class='lparen'>(</span><span class='kw'>self</span><span class='comma'>,</span> <span class='id value'>value</span><span class='rparen'>)</span> <span class='kw'>end</span></pre>
</td>
</tr>
</table>
View
145 doc/CODE_OBJECTS.markdown.html
@@ -1,145 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html>
- <head>
- <meta http-equiv="Content-type" content="text/html; charset=utf-8" />
-<link rel="stylesheet" href="style.css" type="text/css" charset="utf-8" />
-<link rel="stylesheet" href="custom.css" type="text/css" charset="utf-8" />
-<link rel="stylesheet" href="syntax_highlight.css" type="text/css" charset="utf-8" />
-
- <title>CODE_OBJECTS.markdown</title>
- </head>
- <body>
- <div id="content">
- <div class="section docstring readme">
- <h1>CodeObjects Architecture</h1>
-
-<p>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 <tt><a href="YARD/CodeObjects/Base.html" title="YARD::CodeObjects::Base">YARD::CodeObjects::Base</a></tt> class, which
-provides basic attributes like source location, source code, name and path.</p>
-
-<h2>CodeObjects Organization</h2>
-
-<p>Code objects are divided into two basic types. <tt><a href="YARD/CodeObjects/NamespaceObject.html" title="NamespaceObjects">NamespaceObjects</a></tt>
-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 <code>NamespaceObject</code>). 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 <tt><a href="YARD/CodeObjects/RootObject.html" title="RootObject">RootObject</a></tt>
-is a special kind of <code>NamespaceObject</code> which refers to the top level namespace in Ruby.
-Methods that accept a namespace object as a parameter should also accept the symbol
-<code>:root</code> as a shortcut for the root object.</p>
-
-<p>The following is an overview of the classes within the <code>CodeObjects</code> namespace:</p>
-
-<p><img src="images/code-objects-class-diagram.png" alt="CodeObjects Class Diagram" /></p>
-
-<h2>Unique Path Representation</h2>
-
-<p>All CodeObjects are uniquely defined by their implementation of <tt><a href="YARD/CodeObjects/Base.html#path-instance_method" title="YARD::CodeObjects::Base#path">YARD::CodeObjects::Base#path</a></tt>.
-This path is used to locate or store a code object in the <tt><a href="YARD/Registry.html" title="YARD::Registry">YARD::Registry</a></tt>. 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.</p>
-
-<p>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:</p>
-
-<ul>
-<li>Class <code>Klass</code> inside module <code>Mod</code>: <code>Mod::Klass</code></li>
-<li>Instance method <code>bar</code> inside class <code>Foo</code>: <code>Foo#bar</code></li>
-<li>Class method <code>bar</code> inside class <code>Foo</code>: <code>Foo.bar</code></li>
-<li>Constant <code>VERSION</code> inside class <code>YARD</code>: <code>YARD::VERSION</code></li>
-<li>Class variable <code>@@abc</code> inside class <code>A</code>: <code>A::@@abc</code></li>
-</ul>
-
-
-<h2>Registry</h2>
-
-<p>CodeObjects classes are coupled with the <tt><a href="YARD/Registry.html" title="YARD::Registry">YARD::Registry</a></tt> 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 <tt><a href="YARD/Registry.html" title="YARD::Registry">YARD::Registry</a></tt> class.</p>
-
-<h2>Identity Map</h2>
-
-<p>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 <tt><a href="YARD/Registry.html" title="YARD::Registry">YARD::Registry</a></tt>. The following example will only create one object:</p>
-
-<pre class="code"><span class='id id'>id</span> <span class='op'>=</span> <span class='const'>ClassObject</span><span class='period'>.</span><span class='id new'>new</span><span class='lparen'>(</span><span class='symbol'>:root</span><span class='comma'>,</span> <span class='tstring'><span class='tstring_beg'>&quot;</span><span class='tstring_content'>MyClass</span><span class='tstring_end'>&quot;</span></span><span class='rparen'>)</span><span class='period'>.</span><span class='id object_id'>object_id</span> <span class='comment'>#=&gt; 13352
-</span><span class='const'>ClassObject</span><span class='period'>.</span><span class='id new'>new</span><span class='lparen'>(</span><span class='symbol'>:root</span><span class='comma'>,</span> <span class='tstring'><span class='tstring_beg'>&quot;</span><span class='tstring_content'>MyClass</span><span class='tstring_end'>&quot;</span></span><span class='rparen'>)</span><span class='period'>.</span><span class='id object_id'>object_id</span> <span class='comment'>#=&gt; 13352
-</span></pre>
-
-<h2>Proxy Objects</h2>
-
-<p>In addition to providing access to existing objects, a <tt><a href="YARD/CodeObjects/Proxy.html" title="YARD::CodeObjects::Proxy">YARD::CodeObjects::Proxy</a></tt>
-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 <code>Proxy</code> and #type of <code>:proxy</code>,
-for example:</p>
-
-<pre class="code"><span class='const'>P</span><span class='lparen'>(</span><span class='symbol'>:InvalidObject</span><span class='rparen'>)</span><span class='period'>.</span><span class='id type'>type</span> <span class='op'>==</span> <span class='symbol'>:proxy</span> <span class='comment'>#=&gt; true
-</span><span class='const'>P</span><span class='lparen'>(</span><span class='symbol'>:InvalidObject</span><span class='rparen'>)</span><span class='period'>.</span><span class='id is_a?'>is_a?</span><span class='lparen'>(</span><span class='const'>Proxy</span><span class='rparen'>)</span> <span class='comment'>#=&gt; true
-</span></pre>
-
-<h2>Adding Data to Code Objects</h2>
-
-<p>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:</p>
-
-<pre class="code"><span class='id object'>object</span> <span class='op'>=</span> <span class='const'>MethodObject</span><span class='period'>.</span><span class='id new'>new</span><span class='lparen'>(</span><span class='symbol'>:root</span><span class='comma'>,</span> <span class='tstring'><span class='tstring_beg'>&quot;</span><span class='tstring_content'>my_method</span><span class='tstring_end'>&quot;</span></span><span class='rparen'>)</span>
-<span class='id object'>object</span><span class='lbracket'>[</span><span class='symbol'>:modified_at</span><span class='rbracket'>]</span> <span class='op'>=</span> <span class='const'>Time</span><span class='period'>.</span><span class='id now'>now</span>
-</pre>
-
-<p>This value can now be retrieved on this object both by the hash <code>[]</code> syntax as
-well as like any other method:</p>
-
-<pre class="code"><span class='id object'>object</span><span class='period'>.</span><span class='id modified_at'>modified_at</span> <span class='comment'>#=&gt; 2009-06-03 20:08:46 -0400
-</span></pre>
-
-<h2>Creating a Custom CodeObject</h2>
-
-<p>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 <em>might</em> 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.</p>
-
-<p>The <tt><a href="YARD/CodeObjects/Base.html#path-instance_method" title="YARD::CodeObjects::Base#path">YARD::CodeObjects::Base#path</a></tt> 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 <code>FooObject</code>:</p>
-
-<pre class="code"><span class='kw'>def</span> <span class='id path'>path</span>
- <span class='tstring'><span class='tstring_beg'>&quot;</span><span class='tstring_content'>__FooPrefix</span><span class='tstring_end'>&quot;</span></span> <span class='op'>+</span> <span class='id sep'>sep</span> <span class='op'>+</span> <span class='kw'>super</span>
-<span class='kw'>end</span>
-</pre>
-
-<p>Note that if our FooObject is a <code>NamespaceObject</code>, meaning if it can have child
-FooObjects defined inside of it, you may need to verify that the prefix is only
-applied once.</p>
- </div>
- </div>
- <div id="yard_info">
- Generated on Friday, October 16 2009 at 12:40:30 AM by
- <abbr class="yard" title="Yay! A Ruby Documentation Tool"><a href="http://yard.soen.ca">YARD</a></abbr>
- 0.2.3.5 (ruby-1.9.1).
-</div>
-
- </body>
-</html>
View
54 doc/FAQ.markdown.html
@@ -1,54 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html>
- <head>
- <meta http-equiv="Content-type" content="text/html; charset=utf-8" />
-<link rel="stylesheet" href="style.css" type="text/css" charset="utf-8" />
-<link rel="stylesheet" href="custom.css" type="text/css" charset="utf-8" />
-<link rel="stylesheet" href="syntax_highlight.css" type="text/css" charset="utf-8" />
-
- <title>FAQ.markdown</title>
- </head>
- <body>
- <div id="content">
- <div class="section docstring readme">
- <h1>FAQ</h1>
-
-<h2>(1) So, show me some cool stuff. What can YARD do?</h2>
-
-<ul>
-<li><a href="http://gnuu.org/2008/02/29/generating-class-diagrams-with-yard-and-graphviz/">Visualize with GraphViz</a> Visualize your classes and methods with GraphViz</li>
-<li><a href="http://github.com/lsegal/yard/tree/5b07d706eee6bc0d7f13d9ec1e6e0ab914d3679c/lib/yard/core_ext/string.rb">Inline RSpecs</a> In your rspec files, call the following to refer
-back to and call the inline rspecs: <code>described_in_docs "String", "camelcase"</code></li>
-<li><a href="http://github.com/lsegal/yard/tree/master/lib/yard/handlers/base.rb#L350">Inline doc testing</a> Use the 'docspec' command line tool to
-run the above tests. This is similar to <a href="http://github.com/tablatom/rubydoctest">Ruby DocTest</a>'s inline
-irb testing.</li>
-</ul>
-
-
-<h2>(2) Why did you pick the @-symbol tags for documentation?</h2>
-
-<p>Java, C++, Python and many other languages have standard documentation tools
-that use the @tag "standard". This has been extended to the Ruby language,
-and YARD takes advantage of this common style.</p>
-
-<h2>(3) Can I tweak it to use some other documentation standard?</h2>
-
-<p> Yes. YARD is flexible enough to have other documentation syntaxes put into use. [TODO: Add information about customization here.]</p>
-
-<h2>(4) Why don't you use ParseTree, or sydparse? Why did you write your own parser?</h2>
-
-<p>As of Ruby 1.9, YARD uses Ripper parser which is packaged with the standard library
-and maintained as such. The legacy parser is only being maintained for bug fixes,
-but was written because no existing parser properly supported putting comments
-into the parse tree and did not robustly support edge case scenarios.</p>
- </div>
- </div>
- <div id="yard_info">
- Generated on Friday, October 16 2009 at 12:40:30 AM by
- <abbr class="yard" title="Yay! A Ruby Documentation Tool"><a href="http://yard.soen.ca">YARD</a></abbr>
- 0.2.3.5 (ruby-1.9.1).
-</div>
-
- </body>
-</html>
View
50 doc/File.html
@@ -1,6 +1,6 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<meta name="Content-Type" content="text/html; charset=UTF-8" />
<title>Class: File</title>
@@ -12,23 +12,22 @@
if (relpath != '') relpath += '/';
</script>
<script type="text/javascript" charset="utf-8" src="js/jquery.js"></script>
- <script type="text/javascript" charset="utf-8" src="js/autocomplete.js"></script>
<script type="text/javascript" charset="utf-8" src="js/app.js"></script>
</head>
<body>
<div id="header">
<div id="menu">
- <a href="glossary.html">Glossary (F)</a> ::
+ <a href="_index.html">Index (F)</a> &raquo;
- File
+ <span class="title">File</span>
</div>
<div id="search">
- <a id="class_list_link" href="#">Namespace List</a> |
- <a id="method_list_link" href="#">Method List</a> |
+ <a id="class_list_link" href="#">Namespace List</a>
+ <a id="method_list_link" href="#">Method List</a>
<a id ="file_list_link" href="#">File List</a>
</div>
<div class="clear"></div>
@@ -59,14 +58,16 @@
<div class="clear"></div>
<h2>Constant Summary</h2>
- <dl class="constants">
-
- <dt id="RELATIVE_PARENTDIR-constant ">RELATIVE_PARENTDIR =
-
- </dt>
- <dd><pre class="code"><span class='tstring'><span class='tstring_beg'>'</span><span class='tstring_content'>..</span><span class='tstring_end'>'</span></span></pre></dd>
-
- </dl>
+
+ <dl class="constants">
+
+ <dt id="RELATIVE_PARENTDIR-constant ">RELATIVE_PARENTDIR =
+ <span class="summary_desc"></span>
+ </dt>
+ <dd><pre class="code"><span class='tstring'><span class='tstring_beg'>'</span><span class='tstring_content'>..</span><span class='tstring_end'>'</span></span></pre></dd>
+
+ </dl>
+
<h2>Method Summary</h2>
<ul class="summary">
@@ -89,20 +90,19 @@
<div class="method_details">
<p class="signature first" id="relative_path-class_method">
- + (<a href="String.html" title="String">String</a>) relative_path(from, to)
+ + (<tt><a href="String.html" title="String">String</a></tt>) relative_path(from, to)
</p><div class="docstring">
<div class="discussion">
- <p>
+ <p>
Turns a path <tt>to</tt> into a relative path from starting point
<tt>from</tt>. The argument <tt>from</tt> is assumed to be a filename. To
-treat it as a directory, make sure it ends in `File::SEPARATOR`
+treat it as a directory, make sure it ends in <tt>File::SEPARATOR</tt>
(&#8217;/&#8217; on UNIX filesystems).
</p>
-
</div>
</div>
<div class="tags">
@@ -171,19 +171,19 @@
<pre class="lines">
+13
+14
+15
16
17
18
19
20
21
-22
-23
-24
-25</pre>
+22</pre>
</td>
<td>
- <pre class="code"><span class="info file"># File 'lib/yard/core_ext/file.rb', line 16</span>
+ <pre class="code"><span class="info file"># File 'lib/yard/core_ext/file.rb', line 13</span>
<span class='kw'>def</span> <span class='kw'>self</span><span class='period'>.</span><span class='id relative_path'>relative_path</span><span class='lparen'>(</span><span class='id from'>from</span><span class='comma'>,</span> <span class='id to'>to</span><span class='rparen'>)</span>
<span class='id from'>from</span> <span class='op'>=</span> <span class='id expand_path'>expand_path</span><span class='lparen'>(</span><span class='id from'>from</span><span class='rparen'>)</span><span class='period'>.</span><span class='id split'>split</span><span class='lparen'>(</span><span class='const'>SEPARATOR</span><span class='rparen'>)</span>
View
239 doc/GENERATORS.markdown.html
@@ -1,239 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html>
- <head>
- <meta http-equiv="Content-type" content="text/html; charset=utf-8" />
-<link rel="stylesheet" href="style.css" type="text/css" charset="utf-8" />
-<link rel="stylesheet" href="custom.css" type="text/css" charset="utf-8" />
-<link rel="stylesheet" href="syntax_highlight.css" type="text/css" charset="utf-8" />
-
- <title>GENERATORS.markdown</title>
- </head>
- <body>
- <div id="content">
- <div class="section docstring readme">
- <h1>Generators Architecture</h1>
-
-<p>Note: This document describes the architecture of the current generators
-implementation which is likely to undergo large changes in the 0.2.4
-release. Keep this in mind if you plan on extending or implementing
-custom generators.</p>
-
-<p>Generators are the main component in the output generation process of YARD,
-which is invoked when conventional HTML/text output needs to be generated
-for a set of code objects.</p>
-
-<h2>Design Goals</h2>
-
-<p>The general design attempts to be as abstracted from actual content and templates
-as possible. Unlike RDoc which uses one file to describe the entire template,
-YARD splits up the generation of code objects into small components, allowing
-template modification for smaller subsets of a full template without having to
-duplicate the entire template itself. This is necessary because of YARD's support
-for plugins. YARD is designed for extensibility by external plugins, and because
-of this, no one plugin can be responsible for the entire template because no
-one plugin knows about the other plugins being used. For instance, if an RSpec
-plugin was added to support and document specifications in class templates,
-this information would need to be transparently added to the template to work
-in conjunction with any other plugin that performed similar template modifications.
-The design goals can be summarized as follows:</p>
-
-<ol>
-<li>Output should be able to be generated for any arbitrary format with little
-modification to YARD's source code. The addition of extra templates should
-be sufficient.</li>
-<li>The output generated for an object should independently generated data
-from arbitrary sources. These independent components are called "sections".</li>
-<li>Sections should be able to be inserted into any object without affecting
-any existing sections in the document. This allows for easy modification
-of templates by plugins.</li>
-</ol>
-
-
-<h2>Generators</h2>
-
-<p>Generator classes are the objects used to orchestrate the design goals listed
-above. Specifically, they organize the sections and render the template contents
-depending on the format. The main method used to initiate output is the
-<tt>#generate</tt> method which takes a list of
-objects to generate output for. A good example of this is the FullDocGenerator,
-which generates conventional HTML documentation:</p>
-
-<pre class="code"><span class='comment'># all_objects is an array of module and class objects
-</span><span class='const'>Generators</span><span class='op'>::</span><span class='const'>FullDocGenerator</span><span class='period'>.</span><span class='id new'>new</span><span class='lparen'>(</span><span class='id options'>options</span><span class='rparen'>)</span><span class='period'>.</span><span class='id generate'>generate</span><span class='lparen'>(</span><span class='id all_objects'>all_objects</span><span class='rparen'>)</span>
-</pre>
-
-<h2>Generator Options</h2>
-
-<p>A generator keeps state when it is generating output. This state is kept in
-an options hash which is initially passed to it during instantiation. Some
-default options set the template style (<code>:template</code>), the output format (<code>:format</code>),
-and the serializer to use (<code>:serializer</code>). For example, initializing the
-<tt>YARD::Generators::QuickDocGenerator</tt> to output as text instead of HTML can be
-done as follows:</p>
-
-<pre class="code"><span class='const'>YARD</span><span class='op'>::</span><span class='const'>Generators</span><span class='op'>::</span><span class='const'>QuickDocGenerator</span><span class='period'>.</span><span class='id new'>new</span><span class='lparen'>(</span><span class='symbol'>:format</span> <span class='op'>=&gt;</span> <span class='symbol'>:text</span><span class='rparen'>)</span><span class='period'>.</span><span class='id generate'>generate</span><span class='lparen'>(</span><span class='id objects'>objects</span><span class='rparen'>)</span>
-</pre>
-
-<h2>Serializer</h2>
-
-<p>This class abstracts the logic involved in deciding how to serialize data to
-the expected endpoint. For instance, there is both a <tt><a href="YARD/Serializers/StdoutSerializer.html" title="StdoutSerializer">StdoutSerializer</a></tt>
-and <tt><a href="YARD/Serializers/FileSystemSerializer.html" title="FileSystemSerializer">FileSystemSerializer</a></tt> class for
-outputting to console or to a file respectively. When endpoints with locations
-are used (like files or URLs), the serializer implements the <tt><a href="YARD/Serializers/Base.html#serialized_path-instance_method" title="#serialized_path">#serialized_path</a></tt>
-method. This allows the translation from a code object to its path at the endpoint,
-which enables inter-document linking.</p>
-
-<p>Generated objects are automatically serialized using the object if present,
-otherwise the generated object is returned as a string to its parent. Nested
-generator objects automatically set the serializer to nil so that they return
-as a String to their parent.</p>
-
-<h2>Templates</h2>
-
-<p>Templates for a generator are by default found inside the one of the template
-root paths (there can be multiple template paths). A standard template
-directory looks like the following tree:</p>
-
-<pre class="code">(Assuming templates/ is a template root path)
-templates/
-|-- default
-| |-- attributes
-| | |-- html
-| | | `-- header.erb
-| | `-- text
-| | `-- header.erb
-| |-- class
-| | `-- html
-| | `-- header.erb
-| |-- constants
-| | `-- html
-| | |-- constants.erb
-| | |-- header.erb
-| | |-- included.erb
-| | `-- inherited.erb
-...
-</pre>
-
-<p>The path <code>default</code> refers to the template style and the directories at the next
-level (such as <code>attributes</code>) refer to templates for a generator. The next directory
-refers to the output format being used defined by the <code>:format</code> generator option.
-As we saw in the above example, the format option can be set to <code>:text</code>, which
-would use the <code>text/</code> directory instead of <code>html/</code>. Finally, the individual .erb
-files are the sections that make up the generator.</p>
-
-<h2>Sections</h2>
-
-<p>As mentioned above, sections are smaller components that correlate to template
-fragments. Practically speaking, a section can either be a template fragment
-(a conventional .erb file or other supported templating language), a method
-(which returns a String) or another Generator object (which in turn has its own
-list of sections).</p>
-
-<h2>Creating a Generator</h2>
-
-<p>To create a generator, subclass <tt>YARD::Generators::Base</tt> and implement the
-<code>#sections_for(object)</code> method. This method should return a list of sections where
-a Symbol refers to a method or template name and a class refers to a generator.</p>
-
-<pre class="code"><span class='kw'>def</span> <span class='id sections_for'>sections_for</span><span class='lparen'>(</span><span class='id object'>object</span><span class='rparen'>)</span>
- <span class='kw'>case</span> <span class='id object'>object</span>
- <span class='kw'>when</span> <span class='const'>MethodObject</span>
- <span class='lbracket'>[</span><span class='symbol'>:main</span><span class='comma'>,</span> <span class='lbracket'>[</span><span class='const'>G</span><span class='lparen'>(</span><span class='const'>AnotherGenerator</span><span class='rparen'>)</span><span class='rbracket'>]</span><span class='comma'>,</span> <span class='symbol'>:footer</span><span class='rbracket'>]</span>
- <span class='kw'>else</span>
- <span class='lbracket'>[</span><span class='rbracket'>]</span>
- <span class='kw'>end</span>
-<span class='kw'>end</span>
-</pre>
-
-<p>A few points about the above example:</p>
-
-<ul>
-<li>The method can return different lists depending on the object.</li>
-<li>The list of objects is not flat, we will see how nested lists can be used
-in a future example.</li>
-<li>The convenience method <code>G()</code> instantiates a generator out of the class using
-the existing options.</li>
-</ul>
-
-
-<p>If a section is a Symbol, the generator first checks if a method is defined
-with that name, otherwise it checks in the template directories. If a method
-by the symbol name is defined, you need to manually call <tt>#render</tt>
-to return the contents of the template.</p>
-
-<h2>Nested Sections</h2>
-
-<p>Sections often require the ability to encapsulate a set of sub-sections in markup
-(HTML, for instance). Rather than use heavier Generator subclass objects, a more
-lightweight solution is to nest a set of sub-sections as a list that follows
-a section, for example:</p>
-
-<pre class="code"><span class='kw'>def</span> <span class='id sections_for'>sections_for</span><span class='lparen'>(</span><span class='id object'>object</span><span class='rparen'>)</span>
- <span class='lbracket'>[</span><span class='symbol'>:header</span><span class='comma'>,</span> <span class='lbracket'>[</span><span class='symbol'>:section_a</span><span class='comma'>,</span> <span class='symbol'>:section_b</span><span class='rbracket'>]</span><span class='rbracket'>]</span>
-<span class='kw'>end</span>
-</pre>
-
-<p>The above example nests <code>section_a</code> and <code>section_b</code> within the <code>header</code> section.
-Practically speaking, these sections can be placed in the result by <code>yield</code>ing
-to them. A sample header.erb template might contain:</p>
-
-<pre class="code">&amp;lt;h2&amp;gt;Header&amp;lt;/h2&amp;gt;
-&amp;lt;div id=&amp;quot;contents&amp;quot;&amp;gt;
- &amp;lt;%= yield %&amp;gt;
-&amp;lt;/div&amp;gt;
-</pre>
-
-<p>This template code would place the output of <code>section_a</code> and <code>section_b</code> within
-the above div element. Using yield, we can also change the object that is being
-generated. For example, we may want to yield the first method of the class.
-We can do this like so:</p>
-
-<pre class="code">&amp;lt;h2&amp;gt;First method&amp;lt;/h2&amp;gt;
-&amp;lt;%= yield(current_object.meths.first) %&amp;gt;
-</pre>
-
-<p>This would run the nested sections for the method object instead of the class.</p>
-
-<h2>Before Filters</h2>
-
-<p>Generators can run before filters using the <tt>before_section</tt> method
-for all or a specific section to test if the section should be generated or
-skipped. For instance, we can do the following to generate the section :foo only
-for MethodObjects:</p>
-
-<pre class="code"><span class='kw'>class</span> <span class='const'>MyGenerator</span> <span class='op'>&lt;</span> <span class='const'>YARD</span><span class='op'>::</span><span class='const'>Generators</span><span class='op'>::</span><span class='const'>Base</span>
- <span class='id before_section'>before_section</span> <span class='symbol'>:foo</span><span class='comma'>,</span> <span class='symbol'>:is_method?</span>
-
- <span class='kw'>def</span> <span class='id sections_for'>sections_for</span><span class='lparen'>(</span><span class='id object'>object</span><span class='rparen'>)</span>
- <span class='lbracket'>[</span><span class='symbol'>:foo</span><span class='comma'>,</span> <span class='symbol'>:bar</span><span class='comma'>,</span> <span class='symbol'>:baz</span><span class='rbracket'>]</span>
- <span class='kw'>end</span>
-
- <span class='id private'>private</span>
-
- <span class='kw'>def</span> <span class='id is_method?'>is_method?</span><span class='lparen'>(</span><span class='id object'>object</span><span class='rparen'>)</span>
- <span class='id object'>object</span><span class='period'>.</span><span class='id is_a?'>is_a?</span><span class='lparen'>(</span><span class='const'>MethodObject</span><span class='rparen'>)</span>
- <span class='kw'>end</span>
-<span class='kw'>end</span>
-</pre>
-
-<p>Without the argument <code>:foo</code>, the before filter would be applied to all sections.
-Note that we must return <code>false</code> to skip a section. A return type of nil is not
-enough to skip the section.</p>
-
-<p>There is also a <tt>before_list</tt> method to run
-a filter before the entire generator is run. This is useful for doing necessary
-filesystem setup or for generating assets (stylesheets) before generating output
-for the objects. Note that in this case you will need to serialize your data directly
-using the serializer object (described above).</p>
- </div>
- </div>
- <div id="yard_info">
- Generated on Friday, October 16 2009 at 12:40:30 AM by
- <abbr class="yard" title="Yay! A Ruby Documentation Tool"><a href="http://yard.soen.ca">YARD</a></abbr>
- 0.2.3.5 (ruby-1.9.1).
-</div>
-
- </body>
-</html>
View
295 doc/GETTING_STARTED.markdown.html
@@ -1,295 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html>
- <head>
- <meta http-equiv="Content-type" content="text/html; charset=utf-8" />
-<link rel="stylesheet" href="style.css" type="text/css" charset="utf-8" />
-<link rel="stylesheet" href="custom.css" type="text/css" charset="utf-8" />
-<link rel="stylesheet" href="syntax_highlight.css" type="text/css" charset="utf-8" />
-
- <title>GETTING_STARTED.markdown</title>
- </head>
- <body>
- <div id="content">
- <div class="section docstring readme">
- <h1>Getting Started with YARD</h1>
-
-<p>There are a few ways which YARD can be of use to you or your project. This
-document will cover the most common ways to use YARD:</p>
-
-<ul>
-<li><a href="#docing">Documenting Code with YARD</a></li>
-<li><a href="#using">Using YARD to Generate Documentation</a></li>
-<li><a href="#extending">Extending YARD</a></li>
-<li><a href="#templating">Templating YARD</a></li>
-</ul>
-
-
-<p><a name="docing"></a></p>
-
-<h1>Documenting Code with YARD</h1>
-
-<p>By default, YARD is compatible with the same RDoc syntax most Ruby developers
-are already familiar with. However, one of the biggest advantages of YARD is
-the extended meta-data syntax, commonly known as "tags", that you can use
-to express small bits of information in a structured and formal manner. While
-RDoc syntax expects you to describe your method in a completely free-form
-manner, YARD recommends declaring your parameters, return types, etc. with
-the <code>@tag</code> syntax, which makes outputting the documentation more consistent
-and easier to read. Consider the RDoc documentation for a method reverse:</p>
-
-<pre class="code"><span class='comment'># Converts the object into textual markup given a specific `format`
-</span><span class='comment'># (defaults to `:html`)
-</span><span class='comment'>#
-</span><span class='comment'># == Parameters:
-</span><span class='comment'># format::
-</span><span class='comment'># A Symbol declaring the format to convert the object to. This
-</span><span class='comment'># can be `:text` or `:html`.
-</span><span class='comment'>#
-</span><span class='comment'># == Returns:
-</span><span class='comment'># A string representing the object in a specified
-</span><span class='comment'>#
-</span><span class='comment'># format.
-</span><span class='kw'>def</span> <span class='id to_format'>to_format</span><span class='lparen'>(</span><span class='id format'>format</span> <span class='op'>=</span> <span class='symbol'>:html</span><span class='rparen'>)</span>
- <span class='comment'># reverse the string
-</span><span class='kw'>end</span>
-</pre>
-
-<p>While this may seem easy enough to read and understand, it's hard for a machine
-to properly pull this data back out of our documentation. Also we've tied our
-markup to our content, and now our documentation becomes hard to maintain if
-we decide later to change our markup style (maybe we don't want the ":" suffix
-on our headers anymore).</p>
-
-<p>In YARD, we would simply define our method as:</p>
-
-<pre class="code"><span class='comment'># Converts the object into textual markup given a specific format.
-</span><span class='comment'>#
-</span><span class='comment'># @param [Symbol] format the format type, `:text` or `:html`
-</span><span class='comment'># @return [String] the object converted into the expected format.
-</span><span class='kw'>def</span> <span class='id to_format'>to_format</span><span class='lparen'>(</span><span class='id format'>format</span> <span class='op'>=</span> <span class='symbol'>:html</span><span class='rparen'>)</span>
-<span class='kw'>end</span>
-</pre>
-
-<p>Using tags we can add semantic metadata to our code without worrying about
-presentation. YARD will handle presentation for us when we decide to generate
-documentation later.</p>
-
-<h2>Adding Tags to Documentation</h2>
-
-<p>The tag syntax that YARD uses is the same @tag-style syntax you may have seen
-if you've ever coded in Java, Python, PHP, Objective-C or a myriad of other
-languages. The following tag adds an author tag to your class:</p>
-
-<pre class="code"><span class='comment'># @author Loren Segal
-</span><span class='kw'>class</span> <span class='const'>MyClass</span>
-<span class='kw'>end</span>
-</pre>
-
-<p>To allow for large amounts of text, the @tag syntax will recognize any indented
-lines following a tag as part of the tag data. For example:</p>
-
-<pre class="code"><span class='comment'># @deprecated Use {#my_new_method} instead of this method because
-</span><span class='comment'># it uses a library that is no longer supported in Ruby 1.9.
-</span><span class='comment'># The new method accepts the same parameters.
-</span><span class='kw'>def</span> <span class='id mymethod'>mymethod</span>
-<span class='kw'>end</span>
-</pre>
-
-<h2>Declaring Types</h2>
-
-<p>Some tags also have an optional "types" field which let us declare a list of
-types associated with the tag. For instance, a return tag can be declared
-with or without a types field.</p>
-
-<pre class="code"><span class='comment'># @return [String, nil] the contents of our object or nil
-</span><span class='comment'># if the object has not been filled with data.
-</span><span class='kw'>def</span> <span class='id validate'>validate</span><span class='semicolon'>;</span> <span class='kw'>end</span>
-
-<span class='comment'># We don't care about the &quot;type&quot; here:
-</span><span class='comment'># @return the object
-</span><span class='kw'>def</span> <span class='id to_obj'>to_obj</span><span class='semicolon'>;</span> <span class='kw'>end</span>
-</pre>
-
-<p>The list of types is in the form <code>[type1, type2, ...]</code> and is mostly free-form,
-so we can also specify duck-types or constant values. For example:</p>
-
-<pre class="code"><span class='comment'># @param [#to_s] argname any object that responds to `#to_s`
-</span><span class='comment'># @param [true, false] argname only true or false
-</span></pre>
-
-<p>Note the the latter example can be replaced by the meta-type "Boolean", and
-numeric types can be replaced by "Number". These meta-types are by convention
-only, but are recommended.</p>
-
-<p>List types can be specified in the form <code>CollectionClass&lt;ElementType, ...&gt;</code>.
-For instance, consider the following Array that holds a set of Strings and
-Symbols:</p>
-
-<pre class="code"><span class='comment'># @param [Array&lt;String, Symbol&gt;] list the list of strings and symbols.
-</span></pre>
-
-<p><a name="taglist"></a></p>
-
-<h2>List of Tags</h2>
-
-<p>A list of common tags and example usage is below:</p>
-
-<ul>
-<li><p><code>@author</code>: List the author(s) of a class/method</p>
-
-<pre class="code">@author Full Name
-</pre></li>
-<li><p><code>@deprecated</code>: Marks a method/class as deprecated with an optional
-reason.</p>
-
-<pre class="code">@deprecated Describe the reason or provide alt. references here
-</pre></li>
-<li><p><code>@example</code>: Show an example snippet of code for an object. The
-first line is an optional title.</p>
-
-<pre class="code">@example Reverse a string
- &quot;mystring.reverse&quot; #=&gt; &quot;gnirtsym&quot;
-</pre></li>
-<li><p><code>@option</code>: Describe an options hash in a method. The tag takes the
-name of the options parameter first, followed by optional types,
-the option key name, an optional default value for the key and a
-description of the option.</p>
-
-<pre class="code"><span class='comment'># @param [Hash] opts the options to create a message with.
-</span><span class='comment'># @option opts [String] :subject The subject
-</span><span class='comment'># @option opts [String] :from ('nobody') From address
-</span><span class='comment'># @option opts [String] :to Recipient email
-</span><span class='comment'># @option opts [String] :body ('') The email's body
-</span><span class='kw'>def</span> <span class='id send_email'>send_email</span><span class='lparen'>(</span><span class='id opts'>opts</span> <span class='op'>=</span> <span class='lbrace'>{</span><span class='rbrace'>}</span><span class='rparen'>)</span>
-<span class='kw'>end</span>
-</pre></li>
-<li><p><code>@overload</code>: Describe that your method can be used in various
-contexts with various parameters or return types. The first
-line should declare the new method signature, and the following
-indented tag data will be a new documentation string with its
-own tags adding metadata for such an overload.</p>
-
-<pre class="code"><span class='comment'># @overload set(key, value)
-</span><span class='comment'># Sets a value on key
-</span><span class='comment'># @param [Symbol] key describe key param
-</span><span class='comment'># @param [Object] value describe value param
-</span><span class='comment'># @overload set(value)
-</span><span class='comment'># Sets a value on the default key `:foo`
-</span><span class='comment'># @param [Object] value describe value param
-</span><span class='kw'>def</span> <span class='id set'>set</span><span class='lparen'>(</span><span class='op'>*</span><span class='id args'>args</span><span class='rparen'>)</span>
-<span class='kw'>end</span>
-</pre></li>
-<li><p><code>@param</code>: Defines method parameters</p>
-
-<pre class="code">@param [optional, types, ...] argname description
-</pre></li>
-<li><p><code>@raise</code>: Describes an Exception that a method may throw</p>
-
-<pre class="code">@raise [ExceptionClass] description
-</pre></li>
-<li><p><code>@return</code>: Describes return value of method</p>
-
-<pre class="code">@return [optional, types, ...] description
-</pre></li>
-<li><p><code>@see</code>: "See Also" references for an object. Accepts URLs or
-other code objects with an optional description at the end.</p>
-
-<pre class="code">@see http://example.com Description of URL
-@see SomeOtherClass#method
-</pre></li>
-<li><p><code>@since</code>: Lists the version the feature/object was first added</p>
-
-<pre class="code">@since 1.2.4
-</pre></li>
-<li><p><code>@todo</code>: Marks a TODO note in the object being documented</p>
-
-<pre class="code">@todo Add support for Jabberwocky service
- There is an open source Jabberwocky library available
- at http://somesite.com that can be integrated easily
- into the project.
-</pre></li>
-<li><p><code>@version</code>: Lists the version of a class, module or method</p>
-
-<pre class="code">@version 1.0
-</pre></li>
-<li><p><code>@yield</code>: Describes the block. Use types to list the parameter
-names the block yields.</p>
-
-<pre class="code"># for block {|a, b, c| ... }
-@yield [a, b, c] Description of block
-</pre></li>
-<li><p><code>@yieldparam</code>: Defines parameters yielded by a block</p>
-
-<pre class="code">@yieldparam [optional, types, ...] argname description
-</pre></li>
-<li><p><code>@yieldreturn</code>: Defines return type of a block</p>
-
-<pre class="code">@yieldreturn [optional, types, ...] description
-</pre></li>
-</ul>
-
-
-<h2>Other Extended Syntax</h2>
-
-<p><strong>Reference Tags</strong></p>
-
-<p>To minimize rewriting of documentation and to ease maintenance, a special
-tag syntax is allowed to reference tags from other objects. Doing this allows
-a tag to be added as meta-data for multiple objects. A full example of this
-syntax is found in the <a href="TAGS.markdown.html#reftags" title="TAGS.markdown">TAGS.markdown</a> file.</p>
-
-<p><strong>Inter-Document Links</strong></p>
-
-<p>YARD supports a special syntax to link to other code objects or files.
-The syntax is <code>{ObjectName#method OPTIONAL_TITLE}</code>. This syntax is acceptable
-anywhere in documentation with the exception of the @see tag, which
-automatically links its data.</p>
-
-<p><a name="using"></a></p>
-
-<h1>Using YARD to Generate Documentation</h1>
-
-<p>Obviously since YARD is a documentation tool, one of its primary goals is
-to generate documentation for a variety of formats, most commonly HTML. The
-<code>yardoc</code> tool that is installed with YARD allows you to quickly export code
-documentation to HTML document files. In addition to this, YARD ships with
-two more tools allowing you to quickly view <code>ri</code>-style documentation for
-a specific class or method as well as an extra tool to generate UML diagrams
-for your code using <a href="http://www.graphviz.org">Graphviz</a>. An overview of these tools can
-be found in the <a href="README.markdown.html" title="README">README</a> under the Usage section.</p>
-
-<p><a name="extending"></a></p>
-
-<h1>Extending YARD</h1>
-
-<p>There are many ways to extend YARD to support non-standard Ruby syntax (DSLs),
-add new meta-data tags or programmatically access the intermediate metadata
-and documentation from code. An overview of YARD's full architecture can be
-found in the <a href="OVERVIEW.markdown.html" title="OVERVIEW.markdown">OVERVIEW.markdown</a> document.</p>
-
-<p>For information on adding support for Ruby DSLs, see the <a href="HANDLERS.markdown.html" title="HANDLERS.markdown">HANDLERS.markdown</a>
-and <a href="PARSER.markdown.html" title="PARSER.markdown">PARSER.markdown</a> architecture documents.</p>
-
-<p>For information on adding extra tags, see <a href="TAGS.markdown.html" title="TAGS.markdown">TAGS.markdown</a>.</p>
-
-<p>For information on accessing the data YARD stores about your documentation,
-look at the <a href="CODE_OBJECTS.markdown.html" title="CODE_OBJECTS.markdown">CODE_OBJECTS.markdown</a> architecture document.</p>
-
-<p><a name="templating"></a></p>
-
-<h1>Templating YARD</h1>
-
-<p>In many cases you may want to change the style of YARD's templates or add extra
-information after extending it. The <a href="GENERATORS.markdown.html" title="GENERATORS.markdown">GENERATORS.markdown</a> architecture
-document covers the basics of how YARD's templating system works.</p>
- </div>
- </div>
- <div id="yard_info">
- Generated on Friday, October 16 2009 at 12:40:30 AM by
- <abbr class="yard" title="Yay! A Ruby Documentation Tool"><a href="http://yard.soen.ca">YARD</a></abbr>
- 0.2.3.5 (ruby-1.9.1).
-</div>
-
- </body>
-</html>
View
37 doc/GLOSSARY.markdown.html
@@ -1,37 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html>
- <head>
- <meta http-equiv="Content-type" content="text/html; charset=utf-8" />
-<link rel="stylesheet" href="style.css" type="text/css" charset="utf-8" />
-<link rel="stylesheet" href="custom.css" type="text/css" charset="utf-8" />
-<link rel="stylesheet" href="syntax_highlight.css" type="text/css" charset="utf-8" />
-
- <title>GLOSSARY.markdown</title>
- </head>
- <body>
- <div id="content">
- <div class="section docstring readme">
- <h1>Glossary</h1>
-
-<ul>
-<li><p><strong>Code Object</strong>: Any explicitly defined Ruby source that describes a feature
-of the code. By default, this refers to classes, modules, methods, constants
-and class variables, though it can be extended to refer to custom functionality
-defined by a DSL (like a spec, for instance).</p></li>
-<li><p><strong>Domain Specific Language (DSL)</strong>: In the context of Ruby, a DSL is a languge
-optimized for a specific domain (problem) but represented using Ruby syntax.</p></li>
-<li><p><strong>Docstring (Documentation String)</strong>: Comments associated with a code object
-used for documentation purposes.</p></li>
-</ul>
-
- </div>
- </div>
- <div id="yard_info">
- Generated on Friday, October 16 2009 at 12:40:30 AM by
- <abbr class="yard" title="Yay! A Ruby Documentation Tool"><a href="http://yard.soen.ca">YARD</a></abbr>
- 0.2.3.5 (ruby-1.9.1).
-</div>
-
- </body>
-</html>
View
101 doc/Gem/DocManager.html
@@ -1,6 +1,6 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<meta name="Content-Type" content="text/html; charset=UTF-8" />
<title>Class: Gem::DocManager</title>
@@ -12,23 +12,22 @@
if (relpath != '') relpath += '/';
</script>
<script type="text/javascript" charset="utf-8" src="../js/jquery.js"></script>
- <script type="text/javascript" charset="utf-8" src="../js/autocomplete.js"></script>
<script type="text/javascript" charset="utf-8" src="../js/app.js"></script>
</head>
<body>
<div id="header">
<div id="menu">
- <a href="../glossary.html">Glossary (D)</a> ::
+ <a href="../_index.html">Index (D)</a> &raquo;
Gem
- ::
- DocManager
+ &raquo;
+ <span class="title">DocManager</span>
</div>
<div id="search">
- <a id="class_list_link" href="#">Namespace List</a> |
- <a id="method_list_link" href="#">Method List</a> |
+ <a id="class_list_link" href="#">Namespace List</a>
+ <a id="method_list_link" href="#">Method List</a>
<a id ="file_list_link" href="#">File List</a>
</div>
<div class="clear"></div>
@@ -66,6 +65,8 @@
+ <span class="summary_desc"></span>
+
</li>
<li class="public ">
@@ -75,6 +76,8 @@
+ <span class="summary_desc"></span>
+
</li>
<li class="public ">
@@ -84,6 +87,8 @@
+ <span class="summary_desc"></span>
+
</li>
<li class="public ">
@@ -91,6 +96,8 @@
+ <span class="summary_desc"></span>
+
</li>
<li class="public ">
@@ -98,6 +105,8 @@
+ <span class="summary_desc"></span>
+
</li>
<li class="public ">
@@ -105,6 +114,8 @@
+ <span class="summary_desc"></span>
+
</li>
</ul>
@@ -114,7 +125,7 @@
<div class="method_details">
<p class="signature first" id="load_yardoc-class_method">
- + (Object) load_yardoc
+ + (<tt>Object</tt>) load_yardoc
@@ -124,12 +135,12 @@
<pre class="lines">
+25
26
-27
-28</pre>
+27</pre>
</td>
<td>
- <pre class="code"><span class="info file"># File 'lib/rubygems_plugin.rb', line 26</span>
+ <pre class="code"><span class="info file"># File 'lib/rubygems_plugin.rb', line 25</span>
<span class='kw'>def</span> <span class='kw'>self</span><span class='period'>.</span><span class='id load_yardoc'>load_yardoc</span>
<span class='id require'>require</span> <span class='const'>File</span><span class='period'>.</span><span class='id dirname'>dirname</span><span class='lparen'>(</span><span class='kw'>__FILE__</span><span class='rparen'>)</span> <span class='op'>+</span> <span class='tstring'><span class='tstring_beg'>'</span><span class='tstring_content'>/yard</span><span class='tstring_end'>'</span></span>
@@ -142,7 +153,7 @@
<div class="method_details">
<p class="signature " id="install_rdoc_yard-instance_method">
- - (Object) install_rdoc_yard
+ - (<tt>Object</tt>) install_rdoc_yard
@@ -156,20 +167,20 @@
<pre class="lines">
+82
+83
+84
85
86
87
-88
-89
-90
-91</pre>
+88</pre>
</td>
<td>
- <pre class="code"><span class="info file"># File 'lib/rubygems_plugin.rb', line 85</span>
+ <pre class="code"><span class="info file"># File 'lib/rubygems_plugin.rb', line 82</span>
<span class='kw'>def</span> <span class='id install_rdoc_yard'>install_rdoc_yard</span>
<span class='kw'>if</span> <span class='ivar'>@spec</span><span class='period'>.</span><span class='id has_rdoc?'>has_rdoc?</span>
- <span class='cvar'>@@install_rdoc_yard_orig</span><span class='period'>.</span><span class='id bind'>bind</span><span class='lparen'>(</span><span class='kw'>self</span><span class='rparen'>)</span><span class='period'>.</span><span class='id call'>call</span>
+ <span class='id install_rdoc_yard_orig'>install_rdoc_yard_orig</span>
<span class='kw'>elsif</span> <span class='ivar'>@spec</span><span class='period'>.</span><span class='id has_yardoc?'>has_yardoc?</span>
<span class='id install_yardoc'>install_yardoc</span>
<span class='kw'>end</span>
@@ -182,7 +193,7 @@
<div class="method_details">
<p class="signature " id="install_ri_yard-instance_method">
- - (Object) install_ri_yard
+ - (<tt>Object</tt>) install_ri_yard
@@ -196,15 +207,15 @@
<pre class="lines">
-78
-79
-80</pre>
+76
+77
+78</pre>
</td>
<td>
- <pre class="code"><span class="info file"># File 'lib/rubygems_plugin.rb', line 78</span>
+ <pre class="code"><span class="info file"># File 'lib/rubygems_plugin.rb', line 76</span>
<span class='kw'>def</span> <span class='id install_ri_yard'>install_ri_yard</span>
- <span class='cvar'>@@install_ri_yard_orig</span><span class='period'>.</span><span class='id bind'>bind</span><span class='lparen'>(</span><span class='kw'>self</span><span class='rparen'>)</span><span class='period'>.</span><span class='id call'>call</span> <span class='kw'>if</span> <span class='ivar'>@spec</span><span class='period'>.</span><span class='id has_rdoc?'>has_rdoc?</span>
+ <span class='id install_ri_yard_orig'>install_ri_yard_orig</span> <span class='kw'>if</span> <span class='ivar'>@spec</span><span class='period'>.</span><span class='id has_rdoc?'>has_rdoc?</span>
<span class='kw'>end</span></pre>
</td>
</tr>
@@ -214,7 +225,7 @@
<div class="method_details">
<p class="signature " id="install_yardoc-instance_method">
- - (Object) install_yardoc
+ - (<tt>Object</tt>) install_yardoc
@@ -224,17 +235,17 @@
<pre class="lines">
+66
+67
+68
69
70
71
72
-73
-74
-75
-76</pre>
+73</pre>
</td>
<td>
- <pre class="code"><span class="info file"># File 'lib/rubygems_plugin.rb', line 69</span>
+ <pre class="code"><span class="info file"># File 'lib/rubygems_plugin.rb', line 66</span>
<span class='kw'>def</span> <span class='id install_yardoc'>install_yardoc</span>
<span class='id rdoc_dir'>rdoc_dir</span> <span class='op'>=</span> <span class='const'>File</span><span class='period'>.</span><span class='id join'>join</span><span class='lparen'>(</span><span class='ivar'>@doc_dir</span><span class='comma'>,</span> <span class='tstring'><span class='tstring_beg'>'</span><span class='tstring_content'>rdoc</span><span class='tstring_end'>'</span></span><span class='rparen'>)</span>
@@ -252,7 +263,7 @@
<div class="method_details">
<p class="signature " id="run_yardoc-instance_method">
- - (Object) run_yardoc(*args)
+ - (<tt>Object</tt>) run_yardoc(*args)
@@ -262,6 +273,7 @@
<pre class="lines">
+29
30
31
32
@@ -285,12 +297,10 @@
50
51
52
-53
-54
-55</pre>
+53</pre>
</td>
<td>
- <pre class="code"><span class="info file"># File 'lib/rubygems_plugin.rb', line 30</span>
+ <pre class="code"><span class="info file"># File 'lib/rubygems_plugin.rb', line 29</span>
<span class='kw'>def</span> <span class='id run_yardoc'>run_yardoc</span><span class='lparen'>(</span><span class='op'>*</span><span class='id args'>args</span><span class='rparen'>)</span>
<span class='id args'>args</span> <span class='op'>&lt;&lt;</span> <span class='ivar'>@spec</span><span class='period'>.</span><span class='id rdoc_options'>rdoc_options</span>
@@ -308,12 +318,11 @@
<span class='kw'>rescue</span> <span class='const'>Errno</span><span class='op'>::</span><span class='const'>EACCES</span> <span class='op'>=&gt;</span> <span class='id e'>e</span>
<span class='id dirname'>dirname</span> <span class='op'>=</span> <span class='const'>File</span><span class='period'>.</span><span class='id dirname'>dirname</span> <span class='id e'>e</span><span class='period'>.</span><span class='id message'>message</span><span class='period'>.</span><span class='id split'>split</span><span class='lparen'>(</span><span class='tstring'><span class='tstring_beg'>&quot;</span><span class='tstring_content'>-</span><span class='tstring_end'>&quot;</span></span><span class='rparen'>)</span><span class='lbracket'>[</span><span class='int'>1</span><span class='rbracket'>]</span><span class='period'>.</span><span class='id strip'>strip</span>
<span class='id raise'>raise</span> <span class='const'>Gem</span><span class='op'>::</span><span class='const'>FilePermissionError</span><span class='period'>.</span><span class='id new'>new</span><span class='lparen'>(</span><span class='id dirname'>dirname</span><span class='rparen'>)</span>
-<span class='kw'>rescue</span> <span class='const'>RuntimeError</span> <span class='op'>=&gt;</span> <span class='id ex'>ex</span>
+<span class='kw'>rescue</span> <span class='op'>=&gt;</span> <span class='id ex'>ex</span>
<span class='id alert_error'>alert_error</span> <span class='tstring'><span class='tstring_beg'>&quot;</span><span class='tstring_content'>While generating documentation for </span><span class='embexpr_beg'>#{</span><span class='ivar'>@spec</span><span class='period'>.</span><span class='id full_name'>full_name</span><span class='rbrace'>}</span><span class='tstring_end'>&quot;</span></span>
<span class='id ui'>ui</span><span class='period'>.</span><span class='id errs'>errs</span><span class='period'>.</span><span class='id puts'>puts</span> <span class='tstring'><span class='tstring_beg'>&quot;</span><span class='tstring_content'>... MESSAGE: </span><span class='embexpr_beg'>#{</span><span class='id ex'>ex</span><span class='rbrace'>}</span><span class='tstring_end'>&quot;</span></span>
<span class='id ui'>ui</span><span class='period'>.</span><span class='id errs'>errs</span><span class='period'>.</span><span class='id puts'>puts</span> <span class='tstring'><span class='tstring_beg'>&quot;</span><span class='tstring_content'>... YARDDOC args: </span><span class='embexpr_beg'>#{</span><span class='id args'>args</span><span class='period'>.</span><span class='id join'>join</span><span class='lparen'>(</span><span class='tstring'><span class='tstring_beg'>'</span><span class='tstring_content'> </span><span class='tstring_end'>'</span></span><span class='rparen'>)</span><span class='rbrace'>}</span><span class='tstring_end'>&quot;</span></span>
- <span class='id ui'>ui</span><span class='period'>.</span><span class='id errs'>errs</span><span class='period'>.</span><span class='id puts'>puts</span> <span class='tstring'><span class='tstring_beg'>&quot;</span><span class='tstring_content'>\t</span><span class='embexpr_beg'>#{</span><span class='id ex'>ex</span><span class='period'>.</span><span class='id backtrace'>backtrace</span><span class='period'>.</span><span class='id join'>join</span> <span class='tstring'><span class='tstring_beg'>&quot;</span><span class='tstring_content'>\n\t</span><span class='tstring_end'>&quot;</span></span><span class='rbrace'>}</span><span class='tstring_end'>&quot;</span></span> <span class='kw'>if</span>
- <span class='const'>Gem</span><span class='period'>.</span><span class='id configuration'>configuration</span><span class='period'>.</span><span class='id backtrace'>backtrace</span>
+ <span class='id ui'>ui</span><span class='period'>.</span><span class='id errs'>errs</span><span class='period'>.</span><span class='id puts'>puts</span> <span class='tstring'><span class='tstring_beg'>&quot;</span><span class='tstring_content'>\t</span><span class='embexpr_beg'>#{</span><span class='id ex'>ex</span><span class='period'>.</span><span class='id backtrace'>backtrace</span><span class='period'>.</span><span class='id join'>join</span><span class='lparen'>(</span><span class='tstring'><span class='tstring_beg'>&quot;</span><span class='tstring_content'>\n\t</span><span class='tstring_end'>&quot;</span></span><span class='rparen'>)</span><span class='rbrace'>}</span><span class='tstring_end'>&quot;</span></span> <span class='kw'>if</span> <span class='const'>Gem</span><span class='period'>.</span><span class='id configuration'>configuration</span><span class='period'>.</span><span class='id backtrace'>backtrace</span>
<span class='id ui'>ui</span><span class='period'>.</span><span class='id errs'>errs</span><span class='period'>.</span><span class='id puts'>puts</span> <span class='tstring'><span class='tstring_beg'>&quot;</span><span class='tstring_content'>(continuing with the rest of the installation)</span><span class='tstring_end'>&quot;</span></span>
<span class='kw'>ensure</span>
<span class='const'>Dir</span><span class='period'>.</span><span class='id chdir'>chdir</span><span class='lparen'>(</span><span class='id old_pwd'>old_pwd</span><span class='rparen'>)</span>
@@ -326,7 +335,7 @@
<div class="method_details">
<p class="signature " id="setup_rdoc-instance_method">
- - (Object) setup_rdoc
+ - (<tt>Object</tt>) setup_rdoc
@@ -336,19 +345,19 @@
<pre class="lines">
+55
+56
+57
58
59
60
61
62
63
-64
-65
-66
-67</pre>
+64</pre>
</td>
<td>
- <pre class="code"><span class="info file"># File 'lib/rubygems_plugin.rb', line 58</span>
+ <pre class="code"><span class="info file"># File 'lib/rubygems_plugin.rb', line 55</span>
<span class='kw'>def</span> <span class='id setup_rdoc'>setup_rdoc</span>
<span class='kw'>if</span> <span class='const'>File</span><span class='period'>.</span><span class='id exist?'>exist?</span><span class='lparen'>(</span><span class='ivar'>@doc_dir</span><span class='rparen'>)</span> <span class='op'>&amp;&amp;</span> <span class='op'>!</span><span class='const'>File</span><span class='period'>.</span><span class='id writable?'>writable?</span><span class='lparen'>(</span><span class='ivar'>@doc_dir</span><span class='rparen'>)</span> <span class='kw'>then</span>
View
35 doc/Gem/Specification.html
@@ -1,6 +1,6 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<meta name="Content-Type" content="text/html; charset=UTF-8" />
<title>Class: Gem::Specification</title>
@@ -12,23 +12,22 @@
if (relpath != '') relpath += '/';
</script>
<script type="text/javascript" charset="utf-8" src="../js/jquery.js"></script>
- <script type="text/javascript" charset="utf-8" src="../js/autocomplete.js"></script>
<script type="text/javascript" charset="utf-8" src="../js/app.js"></script>
</head>
<body>
<div id="header">
<div id="menu">
- <a href="../glossary.html">Glossary (S)</a> ::
+ <a href="../_index.html">Index (S)</a> &raquo;
Gem
- ::
- Specification
+ &raquo;
+ <span class="title">Specification</span>
</div>
<div id="search">
- <a id="class_list_link" href="#">Namespace List</a> |
- <a id="method_list_link" href="#">Method List</a> |
+ <a id="class_list_link" href="#">Namespace List</a>
+ <a id="method_list_link" href="#">Method List</a>
<a id ="file_list_link" href="#">File List</a>
</div>
<div class="clear"></div>
@@ -66,6 +65,8 @@
+ <span class="summary_desc"></span>
+
</li>
<li class="public ">
@@ -73,6 +74,8 @@
+ <span class="summary_desc"></span>
+
</li>
<li class="public ">
@@ -82,6 +85,8 @@
+ <span class="summary_desc"></span>
+
</li>
</ul>
@@ -91,7 +96,7 @@
<div class="method_details">
<p class="signature first" id="has_yardoc=-class_method">
- + (Object) has_yardoc=(value)
+ + (<tt>Object</tt>) has_yardoc=(value)
@@ -119,7 +124,7 @@
<div class="method_details">
<p class="signature " id="has_rdoc?-instance_method">
- - (Object) has_rdoc?
+ - (<tt>Object</tt>) has_rdoc?
@@ -129,12 +134,12 @@
<pre class="lines">
+17
18
-19
-20</pre>
+19</pre>
</td>
<td>
- <pre class="code"><span class="info file"># File 'lib/rubygems_plugin.rb', line 18</span>
+ <pre class="code"><span class="info file"># File 'lib/rubygems_plugin.rb', line 17</span>
<span class='kw'>def</span> <span class='id has_rdoc?'>has_rdoc?</span>
<span class='ivar'>@has_rdoc</span> <span class='op'>&amp;&amp;</span> <span class='ivar'>@has_rdoc</span> <span class='op'>!=</span> <span class='tstring'><span class='tstring_beg'>'</span><span class='tstring_content'>yard</span><span class='tstring_end'>'</span></span>
@@ -147,7 +152,7 @@
<div class="method_details">
<p class="signature " id="has_yardoc-instance_method">
- - (Object) has_yardoc
+ - (<tt>Object</tt>) has_yardoc
View
0  doc/HANDLERS.markdown.html
Sorry, we could not display the changes to this file because there were too many other changes to display.
View
236 doc/Insertion.html
@@ -1,6 +1,6 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
- "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
-<html>
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
+ "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head>
<meta name="Content-Type" content="text/html; charset=UTF-8" />
<title>Class: Insertion</title>
@@ -12,23 +12,22 @@
if (relpath != '') relpath += '/';
</script>
<script type="text/javascript" charset="utf-8" src="js/jquery.js"></script>
- <script type="text/javascript" charset="utf-8" src="js/autocomplete.js"></script>
<script type="text/javascript" charset="utf-8" src="js/app.js"></script>
</head>
<body>
<div id="header">
<div id="menu">
- <a href="glossary.html">Glossary (I)</a> ::
+ <a href="_index.html">Index (I)</a> &raquo;
- Insertion
+ <span class="title">Insertion</span>
</div>
<div id="search">
- <a id="class_list_link" href="#">Namespace List</a> |
- <a id="method_list_link" href="#">Method List</a> |
+ <a id="class_list_link" href="#">Namespace List</a>
+ <a id="method_list_link" href="#">Method List</a>
<a id ="file_list_link" href="#">File List</a>
</div>
<div class="clear"></div>
@@ -58,7 +57,25 @@
</dl>
<div class="clear"></div>
- <h2>Method Summary</h2>
+<h2>Overview</h2><div class="docstring">
+ <div class="discussion">
+ <p>
+The Insertion class inserts a value before or after another value in a
+list.
+</p>
+
+ </div>
+</div>
+<div class="tags">
+ <div class="examples">
+ <h3>Examples:</h3>
+
+ <h4></h4>
+ <pre class="example code"> <span class='const'>Insertion</span><span class='period'>.</span><span class='id new'>new</span><span class='lparen'>(</span><span class='lbracket'>[</span><span class='int'>1</span><span class='comma'>,</span> <span class='int'>2</span><span class='comma'>,</span> <span class='int'>3</span><span class='rbracket'>]</span><span class='comma'>,</span> <span class='int'>4</span><span class='rparen'>)</span><span class='period'>.</span><span class='id before'>before</span><span class='lparen'>(</span><span class='int'>3</span><span class='rparen'>)</span> <span class='comment'># =&gt; [1, 2, 4, 3]</span></pre>
+
+ </div>
+
+</div> <h2>Method Summary</h2>
<ul class="summary">
<li class="public ">
@@ -66,6 +83,11 @@
+ <span class="summary_desc">
+Inserts the value after <tt>val</tt>.
+
+</span>
+
</li>
<li class="public ">
@@ -73,12 +95,22 @@
+ <span class="summary_desc">
+Inserts the value before <tt>val</tt>.
+
+</span>
+
</li>
<li class="public ">
- <a href="#initialize-instance_method" title="- (Object) initialize(list, value) ">- (Object) initialize(list, value) </a>
+ <a href="#initialize-instance_method" title="- (Insertion) initialize(list, value) ">- (Insertion) initialize(list, value) </a>
+
+ <span class="summary_desc">
+Creates an insertion object on a list with a value to be.
+
+</span>
</li>
@@ -89,20 +121,88 @@
<div class="method_details">
<p class="signature first" id="initialize-instance_method">
- - (Object) initialize(list, value)
+ - (<tt><a href="" title="Insertion">Insertion</a></tt>) initialize(list, value)
+
+
+
+</p><div class="docstring">
+ <div class="discussion">
+ <p>
+Creates an insertion object on a list with a value to be inserted. To
+finalize the insertion, call <tt><a href="#before-instance_method" title="#before">#before</a></tt> or <tt><a href="#after-instance_method" title="#after">#after</a></tt> on the object.
+</p>
+
+ </div>
+</div>
+<div class="tags">
+ <h3>Parameters:</h3>
+<ul class="param">
+
+ <li>
+
+ <span class='type'>(<tt><a href="Array.html" title="Array">Array</a></tt>)</span>
+
+
+ <span class='name'>list</span>
+
+
+
+ &mdash;
+
+the list to perform the insertion on
+
+
+
+ </li>
+
+ <li>
+
+ <span class='type'>(<tt>Object</tt>)</span>
+
+
+ <span class='name'>value</span>
+
+
+
+ &mdash;
+
+the value to insert
+
+
+
+ </li>
+</ul>
+<h3>Returns:</h3>
+<ul class="return">
+
+ <li>
+
+ <span class='type'>(<tt><a href="" title="Insertion">Insertion</a></tt>)</span>
+
+
+
+
+ &mdash;
+
+a new instance of <tt>Insertion</tt>
+
+
+ </li>
-</p><table class="source_code">
+</ul>
+
+</div><table class="source_code">
<tr>
<td>
<pre class="lines">
-6</pre>
+29</pre>
</td>
<td>
- <pre class="code"><span class="info file"># File 'lib/yard/core_ext/array.rb', line 6</span>
+ <pre class="code"><span class="info file"># File 'lib/yard/core_ext/array.rb', line 29</span>
<span class='kw'>def</span> <span class='id initialize'>initialize</span><span class='lparen'>(</span><span class='id list'>list</span><span class='comma'>,</span> <span class='id value'>value</span><span class='rparen'>)</span> <span class='ivar'>@list</span><span class='comma'>,</span> <span class='ivar'>@value</span> <span class='op'>=</span> <span class='id list'>list</span><span class='comma'>,</span> <span class='id value'>value</span> <span class='kw'>end</span></pre>
</td>
@@ -117,20 +217,81 @@
<div class="method_details">
<p class="signature first" id="after-instance_method">
- - (Object) after(val, ignore_subsections = true)
+ - (<tt>Object</tt>) after(val, ignore_subsections = true)
-</p><table class="source_code">
+</p><div class="docstring">
+ <div class="discussion">
+ <p>
+Inserts the value after <tt>val</tt>.
+</p>
+
+ </div>
+</div>
+<div class="tags">
+ <div class="examples">
+ <h3>Examples:</h3>
+
+ <h4>
+If subsections are ignored
+
+</h4>
+ <pre class="example code"> <span class='const'>Insertion</span><span class='period'>.</span><span class='id new'>new</span><span class='lparen'>(</span><span class='lbracket'>[</span><span class='int'>1</span><span class='comma'>,</span> <span class='lbracket'>[</span><span class='int'>2</span><span class='rbracket'>]</span><span class='comma'>,</span> <span class='int'>3</span><span class='rbracket'>]</span><span class='comma'>,</span> <span class='symbol'>:X</span><span class='rparen'>)</span><span class='period'>.</span><span class='id after'>after</span><span class='lparen'>(</span><span class='int'>1</span><span class='rparen'>)</span> <span class='comment'># =&gt; [1, [2], :X, 3]</span></pre>
+
+ </div>
+<h3>Parameters:</h3>
+<ul class="param">
+
+ <li>
+
+ <span class='type'>(<tt>Object</tt>)</span>
+
+
+ <span class='name'>val</span>
+
+
+
+ &mdash;
+
+the object the value will be inserted after
+
+
+
+ </li>
+
+ <li>
+
+ <span class='type'>(<tt>Boolean</tt>)</span>
+
+
+ <span class='name'>ignore_subsections</span>
+
+
+ <em class="default">(defaults to: <tt>true</tt>)</em>
+
+
+ &mdash;
+
+treat any Array objects that follow val as associated and do not split them
+up.
+
+
+
+ </li>
+
+</ul>
+
+</div><table class="source_code">
<tr>
<td>
<pre class="lines">
-8</pre>
+42</pre>
</td>
<td>
- <pre class="code"><span class="info file"># File 'lib/yard/core_ext/array.rb', line 8</span>
+ <pre class="code"><span class="info file"># File 'lib/yard/core_ext/array.rb', line 42</span>
<span class='kw'>def</span> <span class='id after'>after</span><span class='lparen'>(</span><span class='id val'>val</span><span class='comma'>,</span> <span class='id ignore_subsections'>ignore_subsections</span> <span class='op'>=</span> <span class='kw'>true</span><span class='rparen'>)</span> <span class='id insertion'>insertion</span><span class='lparen'>(</span><span class='id val'>val</span><span class='comma'>,</span> <span class='int'>1</span><span class='comma'>,</span> <span class='id ignore_subsections'>ignore_subsections</span><span class='rparen'>)</span> <span class='kw'>end</span></pre>
</td>
@@ -141,20 +302,51 @@
<div class="method_details">
<p class="signature " id="before-instance_method">
- - (Object) before(val)
+ - (<tt>Object</tt>) before(val)
+
+
+
+</p><div class="docstring">
+ <div class="discussion">
+ <p>
+Inserts the value before <tt>val</tt>
+</p>
+
+ </div>
+</div>
+<div class="tags">
+ <h3>Parameters:</h3>
+<ul class="param">
+ <li>
+
+ <span class='type'>(<tt>Object</tt>)</span>
+
+
+ <span class='name'>val</span>
+
+
+
+ &mdash;
+
+the object the value will be inserted before
+
+
+ </li>
-</p><table class="source_code">
+</ul>
+
+</div><table class="source_code">
<tr>
<td>
<pre class="lines">
-7</pre>
+33</pre>
</td>