I find it frustrating when using "ri" to look up documentation on a
class, only to find the method I'm curious about is not listed.
As an example: String objects have many more methods than are explained
in the documentation for String (example: String.grep). When you run
"ri" on String.grep, you get "Nothing known about String.grep". This is
apparently because the grep method was inherited from another class.
Is there any way to have ri automatically check the documentation of
parent classes if no documentation is found for a method of a particular
object? Or is there a better way to access Ruby's documentation than "ri
Class.method"? I don't want to have to do detective work to look up a
simple method...
I find it frustrating when using "ri" to look up documentation on a
class, only to find the method I'm curious about is not listed.
As an example: String objects have many more methods than are explained
in the documentation for String (example: String.grep). When you run
"ri" on String.grep, you get "Nothing known about String.grep". This is
apparently because the grep method was inherited from another class.
Is there any way to have ri automatically check the documentation of
parent classes if no documentation is found for a method of a particular
object? Or is there a better way to access Ruby's documentation than "ri
Class.method"? I don't want to have to do detective work to look up a
simple method...
I usually find rdoc (as available at railsapi.com or ruby-doc.org) to be
more usable than ri.
I find it frustrating when using "ri" to look up documentation on a
class, only to find the method I'm curious about is not listed.
As an example: String objects have many more methods than are explained
in the documentation for String (example: String.grep). When you run
"ri" on String.grep, you get "Nothing known about String.grep". This is
apparently because the grep method was inherited from another class.
Is there any way to have ri automatically check the documentation of
parent classes if no documentation is found for a method of a particular
object? Or is there a better way to access Ruby's documentation than "ri
Class.method"? I don't want to have to do detective work to look up a
simple method...
Maybe you can't find the grep method in String, because it hasn't such a
method?
···
---------------------------------------
ruby -v: ruby 1.9.1p378 (2010-01-10 revision 26273) [x86_64-linux]
irb(main):001:0> "ABC".grep
NoMethodError: undefined method `grep' for "ABC":String
from (irb):1
from
/home/marvin/Programmieren/Programme/ruby_shell/ruby_shell.rb:52:in
`<main>'
irb(main):002:0>
---------------------------------------
And no, I don't know of a way to check inherited methods. But you could
do
---------------------------------------
ri grep
More than one method matched your request. You can refine your
search by asking for information on one of:
Enumerable#grep [Ruby 1.9.1]
Rake::FileList#egrep [gem rake-0.8.7]
---------------------------------------
So, #grep is defined in Enumerable. Then you can look for
Enumerable#grep.
Is there any way to have ri automatically check the documentation of
parent classes if no documentation is found for a method of a particular
object? Or is there a better way to access Ruby's documentation than "ri
Class.method"? I don't want to have to do detective work to look up a
simple method...
Hmm. There is a little utility I use within irb (for me it's easier
than rdoc or ri)
$ gem install ri_for
It doesn't appear helpful in this case (except for telling us that
String might well not have that method).
It does, however, lookup ancestors appropriately if that were the
problem, and run ri against the "right" ancestor.
require 'ri_for'
=> true
''.ri_for :grep
NameError: undefined method `grep' for class `String'
from
E:/installs/ruby191p376/lib/ruby/gems/1.9.1/gems/ri_for-0.5.1/lib/ri_for/method_ri.rb:180:in
`method'
from (irb):2
String.ri_for :grep
NameError: appears that this object String does not have this method
grep
from
E:/installs/ruby191p376/lib/ruby/gems/1.9.1/gems/ri_for-0.5.1/lib/ri_for/method_ri.rb:170:in
`ri_for'
from (irb):3
from E:/installs/ruby191p376/bin/irb:12:in `<main>'
The way ri_for determines the "real" ancestor is to do a .method(:name)
call on it, like
''.method(:select)
=> #<Method: String(Kernel)#select>
within the #inspect output it tells me the real ancestor is Kernel.
GL!
-rp
I find it frustrating when using "ri" to look up documentation on a
class, only to find the method I'm curious about is not listed.
As an example: String objects have many more methods than are explained
in the documentation for String (example: String.grep). When you run
"ri" on String.grep, you get "Nothing known about String.grep". This is
apparently because the grep method was inherited from another class.
So use FastRI instead of RI. It knows to look in the ancestors.
Or do just "ri grep" and it will list the objects where that method is
defined.
I find it frustrating when using "ri" to look up documentation on a
class, only to find the method I'm curious about is not listed.
As an example: String objects have many more methods than are explained
in the documentation for String (example: String.grep). When you run
"ri" on String.grep, you get "Nothing known about String.grep". This is
apparently because the grep method was inherited from another class.
Is there any way to have ri automatically check the documentation of
parent classes if no documentation is found for a method of a particular
object? Or is there a better way to access Ruby's documentation than "ri
Class.method"? I don't want to have to do detective work to look up a
simple method...
Maybe you can't find the grep method in String, because it hasn't such a method?
---------------------------------------
ruby -v: ruby 1.9.1p378 (2010-01-10 revision 26273) [x86_64-linux]
irb(main):001:0> "ABC".grep
NoMethodError: undefined method `grep' for "ABC":String
from (irb):1
from /home/marvin/Programmieren/Programme/ruby_shell/ruby_shell.rb:52:in `<main>'
irb(main):002:0>
---------------------------------------
And no, I don't know of a way to check inherited methods. But you could do
---------------------------------------
ri grep
More than one method matched your request. You can refine your
search by asking for information on one of:
Enumerable#grep [Ruby 1.9.1]
Rake::FileList#egrep [gem rake-0.8.7]
---------------------------------------
So, #grep is defined in Enumerable. Then you can look for Enumerable#grep.
Marvin
------------------------------------------------------------------------
Returns an array of every element in _enum_ for which +Pattern ===
element+. If the optional _block_ is supplied, each matching
element is passed to it, and the block's result is stored in the
output array.
(1..100).grep 38..44 #=> [38, 39, 40, 41, 42, 43, 44]
c = IO.constants
c.grep(/SEEK/) #=> [:SEEK_SET, :SEEK_CUR, :SEEK_END]
res = c.grep(/SEEK/) {|v| IO.const_get(v) }
res #=> [0, 1, 2]
So, at least in 1.9, it seems that what Nick asks for does happen already. Am I missing something?
When looking for the class defining a method, using #instance_method helps:
ri grep
More than one method matched your request. You can refine your
search by asking for information on one of:
This will help. It's not as convenient as automatically checking the
docs for parent classes, but it is at least an easier way of figuring
out where inherited methods come from.
So, at least in 1.9, it seems that what Nick asks for does happen
Interesting. Yeah, I'm working with 1.8.7. I guess that's just one more
reason to upgrade to 1.9! Now if only I can convince my hosting
providers to do so...