Can we move fri into the standard library? (was Re: `ri Kernel#open` Bug)

On Sep 22, 2007, at 7:28 AM, Jim Freeze wrote:

>
> On Sep 21, 2007, at 9:19 PM, James Edward Gray II wrote:
>
>> On Sep 21, 2007, at 8:13 PM, Eric Hodel wrote:
>>
>>> On Sep 21, 2007, at 16:42, James Edward Gray II wrote:
>>>
>>>> $ ri -T Kernel#open
>>>> More than one method matched your request. You can refine
>>>> your search by asking for information on one of:
>>>>
>>>>      Kernel#open, Kernel#open_uri_original_open,  
>>>> Kernel#log_open_files,
>>>>      Kernel#open, Kernel#open
>>>>
>>>> As near as I can tell, it's now impossible to reach the  
>>>> Kernel#open documentation.
>
> You can specify the path for ri to search to get access to the  
> Kernel#open you want,
> but that is a pain and a burden that shouldn't be placed on the user.
>
> Also, a sorted and single-item-per-line choice would be a big  
> improvement.

This might be good time to discuss when we could consider moving  
fastri into the standard library?  It seems to me that ri is going  
downhill and fastri is superior in pretty much every way now.  Is  
there a good reason not to trade up?

$ fri Kernel#open
------------------------------------------------------------ Kernel#open
      open(path [, mode [, perm]] )                => io or nil
      open(path [, mode [, perm]] ) {|io| block }  => obj
------------------------------------------------------------------------
      Creates an IO object connected to the given stream, file, or
      subprocess.

      If path does not start with a pipe character (``|''), treat it as
      the name of a file to open using the specified mode (defaulting to
      ``r''). (See the table of valid modes on page 331.) If a file is
      being created, its initial permissions may be set using the
      integer third parameter.

      If a block is specified, it will be invoked with the File object
      as a parameter, and the file will be automatically closed when the
      block terminates. The call returns the value of the block.

      If path starts with a pipe character, a subprocess is created,
      connected to the caller by a pair of pipes. The returned IO object
      may be used to write to the standard input and read from the
      standard output of this subprocess. If the command following the
      ``|'' is a single minus sign, Ruby forks, and this subprocess is
      connected to the parent. In the subprocess, the open call returns
      nil. If the command is not ``-'', the subprocess runs the command.
      If a block is associated with an open("|-") call, that block will
      be run twice---once in the parent and once in the child. The block
      parameter will be an IO object in the parent and nil in the child.
      The parent's IO object will be connected to the child's $stdin and
      $stdout. The subprocess will be terminated at the end of the  
block.

         open("testfile") do |f|
           print f.gets
         end

      produces:

         This is line one

      Open a subprocess and read its output:

         cmd = open("|date")
         print cmd.gets
         cmd.close

      produces:

         Wed Apr  9 08:56:31 CDT 2003

      Open a subprocess running the same Ruby program:

         f = open("|-", "w+")
         if f == nil
           puts "in Child"
           exit
         else
           puts "Got: #{f.gets}"
         end

      produces:

         Got: in Child

      Open a subprocess using a block to receive the I/O object:

         open("|-") do |f|
           if f == nil
             puts "in Child"
           else
             puts "Got: #{f.gets}"
           end
         end

      produces:

         Got: in Child


      (also known as open_uri_original_open)

James Edward Gray II