ruby-changes:55147
From: nobu <ko1@a...>
Date: Thu, 28 Mar 2019 12:33:40 +0900 (JST)
Subject: [ruby-changes:55147] nobu:r67354 (trunk): [DOC] fix markups [ci skip]
nobu 2019-03-28 12:33:35 +0900 (Thu, 28 Mar 2019) New Revision: 67354 https://svn.ruby-lang.org/cgi-bin/viewvc.cgi?view=revision&revision=67354 Log: [DOC] fix markups [ci skip] Modified files: trunk/pack.c trunk/proc.c trunk/process.c trunk/range.c trunk/re.c trunk/ruby.c trunk/signal.c trunk/symbol.c trunk/thread.c trunk/variable.c trunk/vm_eval.c trunk/vm_method.c Index: pack.c =================================================================== --- pack.c (revision 67353) +++ pack.c (revision 67354) @@ -186,7 +186,7 @@ VALUE_to_float(VALUE obj) https://github.com/ruby/ruby/blob/trunk/pack.c#L186 * exclamation mark (``<code>!</code>'') to use the underlying * platform's native size for the specified type; otherwise, they use a * platform-independent size. Spaces are ignored in the template - * string. See also <code>String#unpack</code>. + * string. See also String#unpack. * * a = [ "a", "b", "c" ] * n = [ 65, 66, 67 ] @@ -1805,7 +1805,7 @@ pack_unpack_internal(VALUE str, VALUE fm https://github.com/ruby/ruby/blob/trunk/pack.c#L1805 * exclamation mark (``<code>!</code>'') to use the underlying * platform's native size for the specified type; otherwise, it uses a * platform-independent consistent size. Spaces are ignored in the - * format string. See also <code>String#unpack1</code>, <code>Array#pack</code>. + * format string. See also String#unpack1, Array#pack. * * "abc \0\0abc \0\0".unpack('A6Z6') #=> ["abc", "abc "] * "abc \0\0".unpack('a3a3') #=> ["abc", " \000\000"] @@ -1922,7 +1922,7 @@ pack_unpack(VALUE str, VALUE fmt) https://github.com/ruby/ruby/blob/trunk/pack.c#L1922 * * Decodes <i>str</i> (which may contain binary data) according to the * format string, returning the first value extracted. - * See also <code>String#unpack</code>, <code>Array#pack</code>. + * See also String#unpack, Array#pack. */ static VALUE Index: vm_eval.c =================================================================== --- vm_eval.c (revision 67353) +++ vm_eval.c (revision 67354) @@ -1357,10 +1357,10 @@ eval_string_with_scope(VALUE scope, VALU https://github.com/ruby/ruby/blob/trunk/vm_eval.c#L1357 * eval(string [, binding [, filename [,lineno]]]) -> obj * * Evaluates the Ruby expression(s) in <em>string</em>. If - * <em>binding</em> is given, which must be a <code>Binding</code> - * object, the evaluation is performed in its context. If the - * optional <em>filename</em> and <em>lineno</em> parameters are - * present, they will be used when reporting syntax errors. + * <em>binding</em> is given, which must be a Binding object, the + * evaluation is performed in its context. If the optional + * <em>filename</em> and <em>lineno</em> parameters are present, they + * will be used when reporting syntax errors. * * def get_binding(str) * return binding @@ -1850,7 +1850,7 @@ uncaught_throw_to_s(VALUE exc) https://github.com/ruby/ruby/blob/trunk/vm_eval.c#L1850 * is no +catch+ block for the _tag_. The optional second * parameter supplies a return value for the +catch+ block, * which otherwise defaults to +nil+. For examples, see - * <code>Kernel::catch</code>. + * Kernel::catch. */ static VALUE Index: range.c =================================================================== --- range.c (revision 67353) +++ range.c (revision 67354) @@ -359,8 +359,7 @@ range_step_size(VALUE range, VALUE args, https://github.com/ruby/ruby/blob/trunk/range.c#L359 * * Iterates over the range, passing each <code>n</code>th element to the block. * If begin and end are numeric, +n+ is added for each iteration. - * Otherwise <code>step</code> invokes <code>succ</code> to iterate through - * range elements. + * Otherwise #step invokes #succ to iterate through range elements. * * If no block is given, an enumerator is returned instead. * Especially, the enumerator is an Enumerator::ArithmeticSequence @@ -1312,9 +1311,8 @@ inspect_range(VALUE range, VALUE dummy, https://github.com/ruby/ruby/blob/trunk/range.c#L1311 * call-seq: * rng.inspect -> string * - * Convert this range object to a printable form (using - * <code>inspect</code> to convert the begin and end - * objects). + * Convert this range object to a printable form (using #inspect to + * convert the begin and end objects). */ @@ -1538,7 +1536,7 @@ range_alloc(VALUE klass) https://github.com/ruby/ruby/blob/trunk/range.c#L1536 return rb_struct_alloc_noinit(klass); } -/* A <code>Range</code> represents an interval---a set of values with a +/* A Range represents an interval---a set of values with a * beginning and an end. Ranges may be constructed using the * <em>s</em><code>..</code><em>e</em> and * <em>s</em><code>...</code><em>e</em> literals, or with Index: proc.c =================================================================== --- proc.c (revision 67353) +++ proc.c (revision 67354) @@ -755,10 +755,10 @@ proc_new(VALUE klass, int8_t is_lambda) https://github.com/ruby/ruby/blob/trunk/proc.c#L755 * Proc.new {|...| block } -> a_proc * Proc.new -> a_proc * - * Creates a new <code>Proc</code> object, bound to the current - * context. <code>Proc::new</code> may be called without a block only - * within a method with an attached block, in which case that block is - * converted to the <code>Proc</code> object. + * Creates a new Proc object, bound to the current context. Proc::new + * may be called without a block only within a method with an + * attached block, in which case that block is converted to the Proc + * object. * * def proc_from * Proc.new @@ -780,7 +780,7 @@ rb_proc_s_new(int argc, VALUE *argv, VAL https://github.com/ruby/ruby/blob/trunk/proc.c#L780 * call-seq: * proc { |...| block } -> a_proc * - * Equivalent to <code>Proc.new</code>. + * Equivalent to Proc.new. */ VALUE @@ -793,8 +793,8 @@ rb_block_proc(void) https://github.com/ruby/ruby/blob/trunk/proc.c#L793 * call-seq: * lambda { |...| block } -> a_proc * - * Equivalent to <code>Proc.new</code>, except the resulting Proc objects - * check the number of parameters passed when called. + * Equivalent to Proc.new, except the resulting Proc objects check the + * number of parameters passed when called. */ VALUE @@ -839,11 +839,11 @@ rb_block_lambda(void) https://github.com/ruby/ruby/blob/trunk/proc.c#L839 * Note that <code>prc.()</code> invokes <code>prc.call()</code> with * the parameters given. It's syntactic sugar to hide "call". * - * For procs created using <code>lambda</code> or <code>->()</code> an error - * is generated if the wrong number of parameters are passed to the proc. - * For procs created using <code>Proc.new</code> or <code>Kernel.proc</code>, - * extra parameters are silently discarded and missing parameters are - * set to +nil+. + * For procs created using #lambda or <code>->()</code> an error is + * generated if the wrong number of parameters are passed to the + * proc. For procs created using Proc.new or Kernel.proc, extra + * parameters are silently discarded and missing parameters are set + * to +nil+. * * a_proc = proc {|a,b| [a,b] } * a_proc.call(1) #=> [1, nil] @@ -921,8 +921,8 @@ rb_proc_call_with_block(VALUE self, int https://github.com/ruby/ruby/blob/trunk/proc.c#L921 * in this latter case, returns n. * Keyword arguments will be considered as a single additional argument, * that argument being mandatory if any keyword argument is mandatory. - * A <code>proc</code> with no argument declarations - * is the same as a block declaring <code>||</code> as its arguments. + * A #proc with no argument declarations is the same as a block + * declaring <code>||</code> as its arguments. * * proc {}.arity #=> 0 * proc { || }.arity #=> 0 @@ -1302,9 +1302,8 @@ proc_to_s(VALUE self) https://github.com/ruby/ruby/blob/trunk/proc.c#L1302 * call-seq: * prc.to_proc -> proc * - * Part of the protocol for converting objects to <code>Proc</code> - * objects. Instances of class <code>Proc</code> simply return - * themselves. + * Part of the protocol for converting objects to Proc objects. + * Instances of class Proc simply return themselves. */ static VALUE @@ -1476,12 +1475,11 @@ method_entry_defined_class(const rb_meth https://github.com/ruby/ruby/blob/trunk/proc.c#L1475 * * Document-class: Method * - * Method objects are created by <code>Object#method</code>, and are - * associated with a particular object (not just with a class). They - * may be used to invoke the method within the object, and as a block - * associated with an iterator. They may also be unbound from one - * object (creating an <code>UnboundMethod</code>) and bound to - * another. + * Method objects are created by Object#method, and are associated + * with a particular object (not just with a class). They may be + * used to invoke the method within the object, and as a block + * associated with an iterator. They may also be unbound from one + * object (creating an UnboundMethod) and bound to another. * * class Thing * def square(n) @@ -1567,8 +1565,8 @@ method_hash(VALUE method) https://github.com/ruby/ruby/blob/trunk/proc.c#L1565 * meth.unbind -> unbound_method * * Dissociates <i>meth</i> from its current receiver. The resulting - * <code>UnboundMethod</code> can subsequently be bound to a new object - * of the same class (see <code>UnboundMethod</code>). + * UnboundMethod can subsequently be bound to a new object of the + * same class (see UnboundMethod). */ static VALUE @@ -1711,10 +1709,9 @@ obj_method(VALUE obj, VALUE vid, int sco https://github.com/ruby/ruby/blob/trunk/proc.c#L1709 * obj.method(sym) -> method * * Looks up the named method as a receiver in <i>obj</i>, returning a - * <code>Method</code> object (or raising <code>NameError</code>). The - * <code>Method</code> object acts as a closure in <i>obj</i>'s object - * instance, so instance variables and the value of <code>self</code> - * remain available. + * Method object (or raising NameError). The Method object acts as a + * closure in <i>obj</i>'s object instance, so instance variables and + * the value of <code>self</code> remain available. * * class Demo * def initialize(n) @@ -1733,8 +1730,8 @@ obj_method(VALUE obj, VALUE vid, int sco https://github.com/ruby/ruby/blob/trunk/proc.c#L1730 * m = l.method("hello") * m.call #=> "Hello, @iv = Fred" * - * Note that <code>Method</code> implements <code>to_proc</code> method, - * which means it can be used with iterators. + * Note that Method implements <code>to_proc</code> method, which + * means it can be used with iterators. * * [ 1, 2, 3 ].each(&method(:puts)) # => prints 3 lines to stdout * @@ -1881,7 +1878,7 @@ rb_mod_public_instance_method(VALUE mod, https://github.com/ruby/ruby/blob/trunk/proc.c#L1878 * Defines an instance method in the receiver. The _method_ * parameter can be a +Proc+, a +Method+ or an +UnboundMethod+ object. * If a block is specified, it is used as the method body. This block - * is evaluated using <code>instance_eval</code>. + * is evaluated using #instance_eval. * * class A * def fred @@ -2190,17 +2187,16 @@ rb_method_call_with_block(int argc, cons https://github.com/ruby/ruby/blob/trunk/proc.c#L2187 * * Document-class: UnboundMethod * - * Ruby supports two forms of objectified methods. Class - * <code>Method</code> is used to represent methods that are associated - * with a particular object: these method objects are bound to that - * object. Bound method objects for an object can be created using - * <code>Object#method</code>. + * Ruby supports two forms of objectified methods. Class Method is + * used to represent methods that are associated with a particular + * object: these method objects are bound to that object. Bound + * method objects for an object can be created using Object#method. * * Ruby also supports unbound methods; methods objects that are not - * associated with a particular object. These can be created either by - * calling <code>Module#instance_method</code> or by calling - * <code>unbind</code> on a bound method object. The result of both of - * these is an <code>UnboundMethod</code> object. + * associated with a particular object. These can be created either + * by calling Module#instance_method or by calling #unbind on a bound + * method object. The result of both of these is an UnboundMethod + * object. * * Unbound methods can only be called after they are bound to an * object. That object must be a kind_of? the method's original @@ -2246,9 +2242,9 @@ rb_method_call_with_block(int argc, cons https://github.com/ruby/ruby/blob/trunk/proc.c#L2242 * call-seq: * umeth.bind(obj) -> method * - * Bind <i>umeth</i> to <i>obj</i>. If <code>Klass</code> was the class - * from which <i>umeth</i> was obtained, - * <code>obj.kind_of?(Klass)</code> must be true. + * Bind <i>umeth</i> to <i>obj</i>. If Klass was the class from which + * <i>umeth</i> was obtained, <code>obj.kind_of?(Klass)</code> must + * be true. * * class A * def test @@ -2725,7 +2721,7 @@ rb_proc_new( https://github.com/ruby/ruby/blob/trunk/proc.c#L2721 * call-seq: * meth.to_proc -> proc * - * Returns a <code>Proc</code> object corresponding to this method. + * Returns a Proc object corresponding to this method. */ static VALUE @@ -3399,7 +3395,7 @@ rb_method_compose_to_right(VALUE self, V https://github.com/ruby/ruby/blob/trunk/proc.c#L3395 * end * C.new.f(1,2) #=> ArgumentError * - * The wrapper <i>def2</i> receives <code>body</code> as a non-lambda proc, + * The wrapper <code>def2</code> receives _body_ as a non-lambda proc, * yet defines a method which has normal semantics. * * == Conversion of other objects to procs @@ -3552,16 +3548,16 @@ Init_Proc(void) https://github.com/ruby/ruby/blob/trunk/proc.c#L3548 } /* - * Objects of class <code>Binding</code> encapsulate the execution - * context at some particular place in the code and retain this context - * for future use. The variables, methods, value of <code>self</code>, - * and possibly an iterator block that can be accessed in this context + * Objects of class Binding encapsulate the execution context at some + * particular place in the code and retain this context for future + * use. The variables, methods, value of <code>self</code>, and + * possibly an iterator block that can be accessed in this context * are all retained. Binding objects can be created using - * <code>Kernel#binding</code>, and are made available to the callback - * of <code>Kernel#set_trace_func</code>. + * Kernel#binding, and are made available to the callback of + * Kernel#set_trace_func. * * These binding objects can be passed as the second argument of the - * <code>Kernel#eval</code> method, establishing an environment for the + * Kernel#eval method, establishing an environment for the * evaluation. * * class Demo Index: thread.c =================================================================== --- thread.c (revision 67353) +++ thread.c (revision 67354) @@ -3255,10 +3255,10 @@ rb_thread_aref(VALUE thread, VALUE key) https://github.com/ruby/ruby/blob/trunk/thread.c#L3255 * * Returns a fiber-local for the given key. If the key can't be * found, there are several options: With no other arguments, it will - * raise a <code>KeyError</code> exception; if <i>default</i> is - * given, then that will be returned; if the optional code block is - * specified, then that will be run and its result returned. - * See Thread#[] and Hash#fetch. + * raise a KeyError exception; if <i>default</i> is given, then that + * will be returned; if the optional code block is specified, then + * that will be run and its result returned. See Thread#[] and + * Hash#fetch. */ static VALUE rb_thread_fetch(int argc, VALUE *argv, VALUE self) Index: vm_method.c =================================================================== --- vm_method.c (revision 67353) +++ vm_method.c (revision 67354) @@ -1031,7 +1031,7 @@ rb_remove_method(VALUE klass, const char https://github.com/ruby/ruby/blob/trunk/vm_method.c#L1031 * remove_method(string) -> self * * Removes the method identified by _symbol_ from the current - * class. For an example, see <code>Module.undef_method</code>. + * class. For an example, see Module.undef_method. * String arguments are converted to symbols. */ Index: process.c =================================================================== --- process.c (revision 67353) +++ process.c (revision 67354) @@ -463,10 +463,10 @@ get_ppid(void) https://github.com/ruby/ruby/blob/trunk/process.c#L463 * * Document-class: Process::Status * - * <code>Process::Status</code> encapsulates the information on the + * Process::Status encapsulates the information on the * status of a running or terminated system process. The built-in * variable <code>$?</code> is either +nil+ or a - * <code>Process::Status</code> object. + * Process::Status object. * * fork { exit 99 } #=> 26557 * Process.wait #=> 26557 @@ -483,7 +483,7 @@ get_ppid(void) https://github.com/ruby/ruby/blob/trunk/process.c#L483 * information (for example the program's return code in the case of * exited processes). Pre Ruby 1.8, these bits were exposed directly * to the Ruby program. Ruby now encapsulates these in a - * <code>Process::Status</code> object. To maximize compatibility, + * Process::Status object. To maximize compatibility, * however, these objects retain a bit-oriented interface. In the * descriptions that follow, when we talk about the integer value of * _stat_, we're referring to this 16 bit value. @@ -538,7 +538,7 @@ rb_last_status_clear(void) https://github.com/ruby/ruby/blob/trunk/process.c#L538 * stat.to_i -> integer * stat.to_int -> integer * - * Returns the bits in _stat_ as a <code>Integer</code>. Poking + * Returns the bits in _stat_ as a Integer. Poking * around in these bits is platform dependent. * * fork { exit 0xab } #=> 26566 @@ -736,9 +736,9 @@ pst_rshift(VALUE st1, VALUE st2) https://github.com/ruby/ruby/blob/trunk/process.c#L736 * call-seq: * stat.stopped? -> true or false * - * Returns +true+ if this process is stopped. This is only - * returned if the corresponding <code>wait</code> call had the - * <code>WUNTRACED</code> flag set. + * Returns +true+ if this process is stopped. This is only returned + * if the corresponding #wait call had the Process::WUNTRACED flag + * set. */ static VALUE @@ -838,8 +838,7 @@ pst_wifexited(VALUE st) https://github.com/ruby/ruby/blob/trunk/process.c#L838 * stat.exitstatus -> integer or nil * * Returns the least significant eight bits of the return code of - * _stat_. Only available if <code>exited?</code> is - * +true+. + * _stat_. Only available if #exited? is +true+. * * fork { } #=> 26572 * Process.wait #=> 26572 @@ -868,7 +867,7 @@ pst_wexitstatus(VALUE st) https://github.com/ruby/ruby/blob/trunk/process.c#L867 * stat.success? -> true, false or nil * * Returns +true+ if _stat_ is successful, +false+ if not. - * Returns +nil+ if <code>exited?</code> is not +true+. + * Returns +nil+ if #exited? is not +true+. */ static VALUE @@ -1241,7 +1240,7 @@ rb_waitpid(rb_pid_t pid, int *st, int fl https://github.com/ruby/ruby/blob/trunk/process.c#L1240 * Process.waitpid(pid=-1, flags=0) -> integer * * Waits for a child process to exit, returns its process id, and - * sets <code>$?</code> to a <code>Process::Status</code> object + * sets <code>$?</code> to a Process::Status object * containing information on that process. Which child it waits on * depends on the value of _pid_: * @@ -1257,8 +1256,8 @@ rb_waitpid(rb_pid_t pid, int *st, int fl https://github.com/ruby/ruby/blob/trunk/process.c#L1256 * value of _pid_. * * The _flags_ argument may be a logical or of the f (... truncated) -- ML: ruby-changes@q... Info: http://www.atdot.net/~ko1/quickml/