From: Robert Klemme <shortcutter@...>
Date: 2010-02-18T02:50:11+09:00
Subject: Re: lookup up documentation for inherited methods

On 02/17/2010 06:12 PM, Marvin Gülker wrote:
> Nick Brown wrote:
>> 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

When I lookup Array#grep I get the documentation of Enumerable#grep it 
seems:

robert@fussel:~$ ri19 -T Array#grep
-------------------------------------------------------- Enumerable#grep
      enum.grep(pattern)                   => array
      enum.grep(pattern) {| obj | block }  => array

      From Ruby 1.9.1
------------------------------------------------------------------------
      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:

robert@fussel:~$ ruby19 -e 'p Array.instance_method :grep'
#<UnboundMethod: Array(Enumerable)#grep>
robert@fussel:~$ ruby19 -v
ruby 1.9.1p376 (2009-12-07 revision 26041) [i686-linux]

Kind regards

	robert

-- 
remember.guy do |as, often| as.you_can - without end
http://blog.rubybestpractices.com/