1#@!#!123s

��JFIF�� 1#@!#!123s
: / opt / alt / ruby34 / share / ri / system / contributing /
Filename : page-documentation_guide_md.ri
back
U:RDoc::TopLevel[	i�I"(contributing/documentation_guide.md:ETcRDoc::Parser::Markdowno:RDoc::Markup::Document:@parts[�S:RDoc::Markup::Heading:
leveli:	textI"Documentation Guide;To:RDoc::Markup::Paragraph;[I"�This guide discusses recommendations for documenting
classes, modules, and methods
in the Ruby core and in the Ruby standard library.;TS;	;
i;I"Generating documentation;To;;[I"nMost Ruby documentation lives in the source files and is written in
{RDoc format}[rdoc-ref:RDoc::Markup].;To;;[I"�Some pages live under the <code>doc</code> folder and can be written in either
<code>.rdoc</code> or <code>.md</code> format, determined by the file extension.;To;;[I"�To generate the output of documentation changes in HTML in the
<code>{build folder}/.ext/html</code> directory, run the following inside your
build directory:;To:RDoc::Markup::Verbatim;[I"make html
;T:@format:sho;;[I"{If you don't have a build directory, follow the {quick start guide}[building_ruby.md#label-Quick+start+guide] up to step 4.;To;;[I"xThen you can preview your changes by opening
<code>{build folder}/.ext/html/index.html</code> file in your browser.;TS;	;
i;I"	Goal;To;;[I"�The goal of Ruby documentation is to impart the most important
and relevant information in the shortest time.
The reader should be able to quickly understand the usefulness
of the subject code and how to use it.;To;;[I"�Providing too little information is bad, but providing unimportant
information or unnecessary examples is not good either.
Use your judgment about what the user needs to know.;TS;	;
i;I"General Guidelines;To:RDoc::Markup::List:
@type:BULLET:@items[
o:RDoc::Markup::ListItem:@label0;[o;;[I"@Keep in mind that the reader may not be fluent in \English.;To;;0;[o;;[I"5Write short declarative or imperative sentences.;To;;0;[o;;[I"TGroup sentences into (ideally short) paragraphs,
 each covering a single topic.;To;;0;[o;;[I"QOrganize material with
 {headings}[rdoc-ref:RDoc::MarkupReference@Headings].;To;;0;[o;;[I"fRefer to authoritative and relevant sources using
 {links}[rdoc-ref:RDoc::MarkupReference@Links].;To;;0;[o;;[I"HUse simple verb tenses: simple present, simple past, simple future.;To;;0;[o;;[I"FUse simple sentence structure, not compound or complex structure.;To;;0;[o;;[I"Avoid:;To;;;;[	o;;0;[o;;[I"aExcessive comma-separated phrases;
 consider a {list}[rdoc-ref:RDoc::MarkupReference@Lists].;To;;0;[o;;[I",Idioms and culture-specific references.;To;;0;[o;;[I"Overuse of headings.;To;;0;[o;;[I"jUsing US-ASCII-incompatible characters in C source files;
 see {Characters}[#label-Characters] below.;TS;	;
i;I"Characters;To;;[I"�Use only US-ASCII-compatible characters in a C source file.
(If you use other characters, the Ruby CI will gently let you know.);To;;[I"�If want to put ASCII-incompatible characters into the documentation
for a C-coded class, module, or method, there are workarounds
involving new files <code>doc/*.rdoc</code>:;To;;;;[o;;0;[o;;[I"�For class <code>Foo</code> (defined in file <code>foo.c</code>),
 create file <code>doc/foo.rdoc</code>, declare <code>class Foo; end</code>,
 and place the class documentation above that declaration:;Fo;
;[I"=# Documentation for class Foo goes here.
class Foo; end
;F;:	rubyo;;0;[o;;[I"�Similarly, for module <code>Bar</code> (defined in file <code>bar.c</code>,
 create file <code>doc/bar.rdoc</code>, declare <code>module Bar; end</code>,
 and place the module documentation above that declaration:;Fo;
;[I"?# Documentation for module Bar goes here.
module Bar; end
;F;;o;;0;[
o;;[I"�For a method, things are different.
 Documenting a method as above disables the "click to toggle source" feature
 in the rendered documentation.;Fo;;[I"/Therefore it's best to use file inclusion:;Fo;;;;[o;;0;[o;;[I"4Retain the <code>call-seq</code> in the C code.;Fo;;0;[o;;[I"TUse file inclusion (<code>:include:</code>) to include text from an .rdoc file.;Fo;;[I"
Example:;Fo;
;[I"�/*
 *  call-seq:
 *    each_byte {|byte| ... } -> self
 *    each_byte               -> enumerator
 *
 *  :include: doc/string/each_byte.rdoc
 *
 */
;F;:cS;	;
i;I"
\RDoc;To;;[I"�Ruby is documented using RDoc.
For information on \RDoc syntax and features, see the
{RDoc Markup Reference}[rdoc-ref:RDoc::Markup@RDoc+Markup+Reference].;TS;	;
i;I"!Output from <code>irb</code>;To;;[I"uFor code examples, consider using interactive Ruby,
{irb}[https://ruby-doc.org/stdlib/libdoc/irb/rdoc/IRB.html].;To;;[I"�For a code example that includes <code>irb</code> output,
consider aligning <code># => ...</code> in successive lines.
Alignment may sometimes aid readability:;To;
;[I"Ya = [1, 2, 3] #=> [1, 2, 3]
a.shuffle!    #=> [2, 3, 1]
a             #=> [2, 3, 1]
;T;;S;	;
i;I"
Headings;To;;[I"oOrganize a long discussion for a class or module with {headings}[rdoc-ref:RDoc::MarkupReference@Headings].;To;;[I"NDo not use formal headings in the documentation for a method or constant.;To;;[I"�In the rare case where heading-like structures are needed
within the documentation for a method or constant, use
{bold text}[rdoc-ref:RDoc::MarkupReference@Bold]
as pseudo-headings.;TS;	;
i;I"Blank Lines;To;;[I")A blank line begins a new paragraph.;To;;[I"�A {code block}[rdoc-ref:RDoc::MarkupReference@Code+Blocks]
or {list}[rdoc-ref:RDoc::MarkupReference@Lists]
should be preceded by and followed by a blank line.
This is unnecessary for the HTML output, but helps in the <code>ri</code> output.;TS;	;
i;I"\Method Names;To;;[I"For a method name in text:;To;;;;[o;;0;[o;;[I"�For a method in the current class or module,
 use a double-colon for a singleton method,
 or a hash mark for an instance method:
 <tt>::bar</tt>, <tt>#baz</tt>.;To;;0;[o;;[I"�Otherwise, include the class or module name
 and use a dot for a singleton method,
 or a hash mark for an instance method:
 <tt>Foo.bar</tt>, <tt>Foo#baz</tt>.;TS;	;
i;I"Embedded Code and Commands;To;;[I"�Code or commands embedded in running text (i.e., not in a code block)
should marked up as
{monofont}[rdoc-ref:RDoc::MarkupReference@Monofont].;To;;[I"ACode that is a simple string should include the quote marks.;TS;	;
i;I"Auto-Linking;To;;[I"GMost often, the name of a class, module, or method
is auto-linked:;To;
;[I"4- Float.
- Enumerable.
- File.new
- File#read.
;T;:	rdoco;;[I"renders as:;To:RDoc::Markup::BlockQuote;[o;;;;[	o;;0;[o;;[I"Float.;To;;0;[o;;[I"Enumerable.;To;;0;[o;;[I"
File.new;To;;0;[o;;[I"File#read.;To;;[I"�In general, \RDoc's auto-linking should not be suppressed.
For example, we should write just plain _Float_ (which is auto-linked):;To;
;[I"Returns a Float.
;T;;o;;[I"which renders as:;To;;[o;;[I"Returns a Float.;To;;[I"�However, _do_ suppress auto-linking when the word in question
does not refer to a Ruby entity (e.g., some uses of _Class_ or _English_):;To;
;[I"%\Class variables can be tricky.
;T;;o;;[I"renders as:;To;;[o;;[I"#Class variables can be tricky.;To;;[I"�Also, _do_ suppress auto-linking when the word in question
refers to the current document
(e.g., _Float_ in the documentation for class Float).;To;;[I"�In this case you may consider forcing the name to
{monofont}[rdoc-ref:RDoc::MarkupReference@Monofont],
which suppresses auto-linking, and also emphasizes that the word is a class name:;To;
;[I"&A +Float+ object represents ....
;T;;o;;[I"renders as:;To;;[o;;[I"0A <code>Float</code> object represents ....;To;;[I"�For a _very_ few, _very_ often-discussed classes,
you might consider avoiding the capitalized class name altogether.
For example, for some mentions of arrays,
you might write simply the lowercase _array_.;To;;[I"Instead of:;To;
;[I"For an empty Array, ....
;T;;o;;[I"which renders as:;To;;[o;;[I"For an empty Array, ....;To;;[I"you might write:;To;
;[I"For an empty array, ....
;T;;o;;[I"which renders as:;To;;[o;;[I"For an empty array, ....;To;;[I"vThis more casual usage avoids both auto-linking and distracting font changes,
and is unlikely to cause confusion.;To;;[I"@This principle may be usefully applied, in particular, for:;To;;;;[	o;;0;[o;;[I"An array.;To;;0;[o;;[I"An integer.;To;;0;[o;;[I"A hash.;To;;0;[o;;[I"A string.;To;;[I"�However, it should be applied _only_ when referring to an _instance_ of the class,
and _never_ when referring to the class itself.;TS;	;
i;I"Explicit Links;To;;[I"<When writing an explicit link, follow these guidelines.;TS;	;
i	;I"+rdoc-ref+ Scheme;To;;[I"#Use the +rdoc-ref+ scheme for:;To;;;;[o;;0;[o;;[I">A link in core documentation to other core documentation.;To;;0;[o;;[I"QA link in core documentation to documentation in a standard library package.;To;;0;[o;;[I"hA link in a standard library package to other documentation in that same
 standard library package.;To;;[I"VSee section "+rdoc-ref+ Scheme" in {Links}[rdoc-ref:RDoc::MarkupReference@Links].;TS;	;
i	;I"URL-Based Link;To;;[I"#Use a full URL-based link for:;To;;;;[o;;0;[o;;[I"KA link in standard library documentation to documentation in the core.;To;;0;[o;;[I"hA link in standard library documentation to documentation in a different
 standard library package.;To;;[I"�Doing so ensures that the link will valid even when the package documentation
is built independently (separately from the core documentation).;To;;[I"OThe link should lead to a target in https://docs.ruby-lang.org/en/master/.;To;;[I"GAlso use a full URL-based link for a link to an off-site document.;TS;	;
i;I"Variable Names;To;;[I"�The name of a variable (as specified in its call-seq) should be marked up as
{monofont}[rdoc-ref:RDoc::MarkupReference@Monofont].;To;;[I"~Also, use monofont text for the name of a transient variable
(i.e., one defined and used only in the discussion, such as +n+).;TS;	;
i;I"HTML Tags;To;;[I"�In general, avoid using HTML tags (even in formats where it's allowed)
because <code>ri</code> (the Ruby Interactive reference tool)
may not render them properly.;TS;	;
i;I"Tables;To;;[I"RIn particular, avoid building tables with HTML tags
(<tt><table></tt>, etc.).;To;;[I"Alternatives:;To;;;;[o;;0;[o;;[I"�A {verbatim text block}[rdoc-ref:RDoc::MarkupReference@Verbatim+Text+Blocks],
 using spaces and punctuation to format the text;
 note that {text markup}[rdoc-ref:RDoc::MarkupReference@Text+Markup]
 will not be honored:;Fo;;;;[o;;0;[o;;[I"uExample {source}[https://github.com/ruby/ruby/blob/34d802f32f00df1ac0220b62f72605827c16bad8/file.c#L6570-L6596].;Fo;;0;[o;;[I"=Corresponding {output}[rdoc-ref:File@Read-2FWrite+Mode].;Fo;;0;[o;;[I"�(Markdown format only): A {Github Flavored Markdown (GFM) table}[https://github.github.com/gfm/#tables-extension-],
 using special formatting for the text:;Fo;;;;[o;;0;[o;;[I"�Example {source}[https://github.com/ruby/ruby/blob/34d802f32f00df1ac0220b62f72605827c16bad8/doc/contributing/glossary.md?plain=1].;Fo;;0;[o;;[I"`Corresponding {output}[https://docs.ruby-lang.org/en/master/contributing/glossary_md.html].;FS;	;
i;I"$Documenting Classes and Modules;To;;[I"JThe general structure of the class or module documentation should be:;To;;;;[o;;0;[o;;[I"
Synopsis;To;;0;[o;;[I"Common uses, with examples;To;;0;[o;;[I"%"What's Here" summary (optional);TS;	;
i;I"
Synopsis;To;;[I"�The synopsis is a short description of what the class or module does
and why the reader might want to use it.
Avoid details in the synopsis.;TS;	;
i;I"Common Uses;To;;[I"�Show common uses of the class or module.
Depending on the class or module, this section may vary greatly
in both length and complexity.;TS;	;
i;I"What's Here Summary;To;;[I"QThe documentation for a class or module may include a "What's Here" section.;To;;[I"Guidelines:;To;;;;[o;;0;[o;;[I"3The section title is <code>What's Here</code>.;Fo;;0;[o;;[I"�Consider listing the parent class and any included modules; consider
 {links}[rdoc-ref:RDoc::MarkupReference@Links]
 to their "What's Here" sections if those exist.;Fo;;0;[o;;[I"All methods mentioned in the left-pane table of contents
 should be listed (including any methods extended from another class).;Fo;;0;[o;;[I"GAttributes (which are not included in the TOC) may also be listed.;Fo;;0;[o;;[I":Display methods as items in one or more bullet lists:;Fo;;;;[o;;0;[o;;[I"XBegin each item with the method name, followed by a colon
 and a short description.;Fo;;0;[o;;[I"wIf the method has aliases, mention them in parentheses before the colon
 (and do not list the aliases separately).;Fo;;0;[o;;[I"�Check the rendered documentation to determine whether \RDoc has recognized
 the method and linked to it; if not, manually insert a
 {link}[rdoc-ref:RDoc::MarkupReference@Links].;Fo;;0;[o;;[I"ZIf there are numerous entries, consider grouping them into subsections with headings.;Fo;;0;[o;;[I"{If there are more than a few such subsections,
 consider adding a table of contents just below the main section title.;FS;	;
i;I"Documenting Methods;TS;	;
i;I"General Structure;To;;[I"AThe general structure of the method documentation should be:;To;;;;[o;;0;[o;;[I"1Calling sequence (for methods written in C).;To;;0;[o;;[I""Synopsis (short description).;To;;0;[o;;[I"!In-brief examples (optional);To;;0;[o;;[I"Details and examples.;To;;0;[o;;[I")Argument description (if necessary).;To;;0;[o;;[I"!Corner cases and exceptions.;To;;0;[o;;[I" Related methods (optional).;TS;	;
i;I"0Calling Sequence (for methods written in C);To;;[I"UFor methods written in Ruby, \RDoc documents the calling sequence automatically.;To;;[I"�For methods written in C, \RDoc cannot determine what arguments
the method accepts, so those need to be documented using \RDoc directive
{<code>call-seq:</code>}[rdoc-ref:RDoc::MarkupReference@Directives+for+Method+Documentation].;To;;[I"*For a singleton method, use the form:;To;
;[I"Lclass_name.method_name(method_args) {|block_args| ... } -> return_type
;T;;o;;[I"
Example:;To;
;[I"n*  call-seq:
*    Hash.new(default_value = nil) -> new_hash
*    Hash.new {|hash, key| ... } -> new_hash
;T;;o;;[I"kFor an instance method, use the form
(omitting any prefix, just as RDoc does for a Ruby-coded method):;To;
;[I"Amethod_name(method_args) {|block_args| ... } -> return_type
;T;;o;;[I" For example, in Array, use:;To;
;[I"j*  call-seq:
*    count -> integer
*    count(obj) -> integer
*    count {|element| ... } -> integer
;T;;o;
;[I"5*  call-seq:
*    <=> other -> -1, 0, 1, or nil
;T;;o;;[I"�For a binary-operator style method (e.g., Array#&),
cite <code>self</code> in the call-seq (not, e.g., <code>array</code> or <code>receiver</code>):;To;
;[I"7*  call-seq:
*    self & other_array -> new_array
;T;;o;;[I"Arguments:;To;;;;[o;;0;[o;;[I"CIf the method does not accept arguments, omit the parentheses.;Fo;;0;[o;;[I".If the method accepts optional arguments:;Fo;;;;[o;;0;[o;;[I"qSeparate each argument name and its default value with <code>=</code>
 (equal-sign with surrounding spaces).;Fo;;0;[o;;[I"�If the method has the same behavior with either an omitted
 or an explicit argument, use a <code>call-seq</code> with optional arguments.
 For example, use:;Fo;
;[I"Q*  call-seq:
*    respond_to?(symbol, include_all = false) -> true or false
;F;;o;;0;[o;;[I"�If the behavior is different with an omitted or an explicit argument,
 use a <code>call-seq</code> with separate lines.
 For example, in Enumerable, use:;Fo;
;[I">*  call-seq:
*    max    -> element
*    max(n) -> array
;F;;o;;[I"Block:;To;;;;[o;;0;[o;;[I";If the method does not accept a block, omit the block.;Fo;;0;[o;;[I"�If the method accepts a block, the <code>call-seq</code> should have <code>{|args| ... }</code>,
 not <code>{|args| block }</code> or <code>{|args| code }</code>.;Fo;;0;[o;;[I"�If the method accepts a block, but returns an Enumerator when the block is omitted,
 the <code>call-seq</code> should show both forms:;Fo;
;[I"f*  call-seq:
*    array.select {|element| ... } -> new_array
*    array.select -> new_enumerator
;F;;o;;[I"Return types:;To;;;;[	o;;0;[o;;[I"pIf the method can return multiple different types,
 separate the types with "or" and, if necessary, commas.;To;;0;[o;;[I";If the method can return multiple types, use +object+.;To;;0;[o;;[I"4If the method returns the receiver, use +self+.;To;;0;[o;;[I"�If the method returns an object of the same class,
 prefix <code>new_</code> if an only if the object is not +self+;
 example: <code>new_array</code>.;To;;[I"
Aliases:;To;;;;[o;;0;[o;;[I"BOmit aliases from the <code>call-seq</code>, unless the alias is an
 operator method. If listing both a regular method and an
 operator method in the <code>call-seq</code>, explain in the details and
 examples section when it is recommended to use the regular method
 and when it is recommended to use the operator method.;TS;	;
i;I"
Synopsis;To;;[I"�The synopsis comes next, and is a short description of what the
method does and why you would want to use it. Ideally, this
is a single sentence, but for more complex methods it may require
an entire paragraph.;To;;[I"3For <code>Array#count</code>, the synopsis is:;To;;[o;;[I"+Returns a count of specified elements.;To;;[I"�This is great as it is short and descriptive. Avoid documenting
too much in the synopsis, stick to the most important information
for the benefit of the reader.;TS;	;
i;I"In-Brief Examples;To;;[I"�For a method whose documentation is lengthy,
consider adding an "in-brief" passage,
showing examples that summarize the method's uses.;To;;[I"{The passage may answer some users' questions
(without their having to read long documentation);
see Array#[] and Array#[]=.;TS;	;
i;I"Details and Examples;To;;[I"vMost non-trivial methods benefit from examples, as well as details
beyond what is given in the synopsis. In the details and examples
section, you can document how the method handles different types
of arguments, and provides examples on proper usage. In this
section, focus on how to use the method properly, not on how the
method handles improper arguments or corner cases.;To;;[I"�Not every behavior of a method requires an example. If the method
is documented to return <code>self</code>, you don't need to provide an example
showing the return value is the same as the receiver. If the method
is documented to return <code>nil</code>, you don't need to provide an example
showing that it returns <code>nil</code>. If the details mention that for a
certain argument type, an empty array is returned, you don't need
to provide an example for that.;To;;[I"�Only add an example if it provides the user additional information,
do not add an example if it provides the same information given
in the synopsis or details. The purpose of examples is not to prove
what the details are stating.;To;;[I"�Many methods that can take an optional block call the block if it is given,
but return a new Enumerator if the block is not given;
in that case, do not provide an example,
but do state the fact (with the auto-linking uppercase Enumerator):;To;
;[I"7*  With no block given, returns a new Enumerator.
;T;;S;	;
i;I"(Argument Description (if necessary);To;;[I"For methods that require arguments, if not obvious and not explicitly
mentioned in the details or implicitly shown in the examples, you can
provide details about the types of arguments supported. When discussing
the types of arguments, use simple language even if less-precise, such
as "level must be an integer", not "level must be an Integer-convertible
object". The vast majority of use will be with the expected type, not an
argument that is explicitly convertible to the expected type, and
documenting the difference is not important.;To;;[I"�For methods that take blocks, it can be useful to document the type of
argument passed if it is not obvious, not explicitly mentioned in the
details, and not implicitly shown in the examples.;To;;[I"~If there is more than one argument or block argument, use a
{labeled list}[rdoc-ref:RDoc::MarkupReference@Labeled+Lists].;TS;	;
i;I" Corner Cases and Exceptions;To;;[I"xFor corner cases of methods, such as atypical usage, briefly mention
the behavior, but do not provide any examples.;To;;[I"|Only document exceptions raised if they are not obvious. For example,
if you have stated earlier than an argument type must be an integer,
you do not need to document that a <code>TypeError</code> is raised if a non-integer
is passed. Do not provide examples of exceptions being raised unless
that is a common case, such as <code>Hash#fetch</code> raising a <code>KeyError</code>.;TS;	;
i;I"Related Methods (optional);To;;[I"In some cases, it is useful to document which methods are related to
the current method. For example, documentation for <code>Hash#[]</code> might
mention <code>Hash#fetch</code> as a related method, and <code>Hash#merge</code> might mention
<code>Hash#merge!</code> as a related method.;To;;;;[o;;0;[o;;[I"�Consider which methods may be related
 to the current method, and if you think the reader would benefit it,
 at the end of the method documentation, add a line starting with
 "Related: " (e.g. "Related: #fetch.").;Fo;;0;[o;;[I"�Don't list more than three related methods.
 If you think more than three methods are related,
 list the three you think are most important.;Fo;;0;[o;;[I"Consider adding:;Fo;;;;[o;;0;[o;;[I"�A phrase suggesting how the related method is similar to,
 or different from,the current method.
 See an example at Time#getutc.;Fo;;0;[o;;[I"zExample code that illustrates the similarities and differences.
 See examples at Time#ctime, Time#inspect, Time#to_s.;FS;	;
i;I".Methods Accepting Multiple Argument Types;To;;[I"�For methods that accept multiple argument types, in some cases it can
be useful to document the different argument types separately. It's
best to use a separate paragraph for each case you are discussing.;T:
@file@:0@omit_headings_from_table_of_contents_below0