dakrone-fastri 0.3.1

data/README.en

@@ -0,0 +1,102 @@
+FastRI Copyright (C) 2006  Mauricio Fernandez <mfp@acm.org>
+Inspired by ri-emacs.rb by Kristof Bastiaensen <kristof@vleeuwen.org>
+
+Overview
+========
+FastRI is an alternative to the ri command-line tool. It is *much* faster, and
+also allows you to offer RI lookup services over DRb. FastRI is a bit smarter
+than ri, and can find classes anywhere in the hierarchy without specifying the
+"full path". It also knows about gems, and can tell you e.g. which extensions
+to a core class were added by a specific gem.
+
+Install
+=======
+Just run  
+  setup.rb
+
+Usage
+=====
+FastRI can be used either standalone or with a DRb server, for extra speed.
+
+The standalone client is qri and is used the same way as ri; run
+ $ qri -h
+to list the options.
+
+There are two parts to FastRI over DRb:
+* the server: fastri-server
+* the client: fri
+
+FastRI uses a Rinda Ring to allow servers to be discovered automatically
+without needing to indicate the DRb URIs manually. It can work across 
+machines if you make sure the ring server is bound to the correct interface,
+and the ACL permissions are correct.
+
+qri and fri are nearly identical, the only difference being that fri tries to
+use a FastRI service over DRb by default.
+
+fri Quickstart
+--------------
+ $ fastri-server             (blocks)
+Later,
+ $ fri String
+ ---------------------------------------------------------- Class: String
+      A String object holds and manipulates an arbitrary sequence of
+      bytes, typically representing characters. String objects may be
+      created using String::new or as literals.
+ ...
+
+Read on for more information, including how to make FastRI work across
+machines.
+
+Launching the server
+--------------------
+For local usage, just
+  $ fastri-server
+will do. The DRb service will bind to 127.0.0.1, and only connections from
+127.0.0.1 will be allowed. If you want to allow fri to be used from other
+machines, you have to specify which interface to bind to, and allow incoming 
+connections from the desired hosts. For example, if your network is
+192.168.1.0, and your IP is 192.168.1.2, you can do
+  $ fastri-server -a 192.168.1.0/24 -s 192.168.1.2
+  FastRI 0.0.1 listening on druby://192.168.1.2:41217
+  ACL:
+  deny  all
+  allow localhost
+  allow 192.168.1.0/24
+
+Further options are documented in
+  $ fastri-server -h
+
+Using fri
+---------
+Running fri with no options (or -h/--help) will explain the command-line options.
+If you are using fri locally (i.e. on the same server as fastri-server), just use
+it as follows:
+  $ fri Array
+  ------------------------------------------------------- Class: Array
+  Arrays are ordered, integer-indexed collections of any object.
+  ...
+
+If you're on a different machine, you'll probably have to specify which
+address the DRb service should be attached to. You can either specify it with
+-s ADDRESS  (or --bind ADDRESS), or set the FASTRI_ADDR environment variable.
+For example, if you're on 192.168.1.101, both
+  export FASTRI_ADDR="192.168.1.101"
+  fri Array
+and
+  fri -s 192.168.1.101 Array
+will work. Note that FASTRI_ADDR is the *local* address: the server will be
+discovered automatically. (The reason why the local address must be specified
+is that it will be given to the ring server, which must be able to establish
+a reverse connection through the local DRb service.)
+
+Feedback
+========
+Bug reports, patches, comments... are appreciated.
+You can contact the author via <mfp@acm.org>. Please add "fastri" to the
+subject in order to bypass the spam filters.
+
+License
+=======
+FastRI is licensed under the same terms as Ruby. See LICENSE.
+

data/Rakefile

@@ -0,0 +1,26 @@
+$:.unshift "lib" if File.directory? "lib"
+require 'rake/testtask'
+
+desc "Run the functional and unit tests."
+Rake::TestTask.new(:test) do |t|
+  t.test_files = FileList['test/test*.rb']
+  t.verbose = true
+end
+
+require 'rcov/rcovtask'
+desc "Run rcov."
+Rcov::RcovTask.new do |t|
+  t.test_files = FileList['test/test_*.rb'].to_a.reject{|x| /test_functional/ =~ x}
+  t.verbose = true
+end
+
+desc "Save current coverage state for later comparisons."
+Rcov::RcovTask.new(:rcovsave) do |t|
+  t.rcov_opts << "--save"
+  t.test_files = FileList['test/test_*.rb'].to_a.reject{|x| /test_functional/ =~ x}
+  t.verbose = true
+end
+
+task :default => :test
+
+# vim: set sw=2 ft=ruby:

data/THANKS

@@ -0,0 +1,36 @@
+
+Tomasz Wegrzanowski
+===================
+* contributed the code that allows fri to find a method in the ancestors
+  for core classes
+
+Dee Zsombor
+===========
+* reported problem with ri-emacs setting $stdout.sync to true
+
+Greg Weber
+==========
+* came up with the idea to load optparse only when needed,
+  saving some 10-30ms per run.
+
+Steven Lumos
+============
+* found bug triggered by hyphens in Gem.path
+
+Lee Marlow
+==========
+* helped fix FastRI on Leopard
+
+Steve Madsen
+============
+* reported the problems on Leopard and tested the patches
+
+Nikolai Lugovoi
+===============
+* implemented -a (--all)
+
+rubikitch
+=========
+* ri-emacs work
+* -1 (--exact)
+* fixes

data/bin/fastri-server

@@ -0,0 +1,251 @@
+#!/usr/bin/env ruby
+# fastri-server: serve RI documentation over DRb 
+# Copyright (C) 2006  Mauricio Fernandez <mfp@acm.org>
+
+require 'fastri/version'
+require 'fastri/ri_index'
+require 'fastri/ri_service'
+require 'fastri/util'
+require 'fastri/full_text_indexer'
+require 'enumerator'
+
+FASTRI_SERVER_VERSION = "0.0.1"
+
+def make_index(index_file)
+  # The local environment is trusted --- what we don't trust is what would come
+  # from the DRb connection. This way the RiService will be untainted, and we
+  # will be able to use it with $SAFE = 1.
+  ObjectSpace.each_object{|obj| obj.untaint unless obj.frozen? }
+
+  paths = [ ::RDoc::RI::Paths::SYSDIR, ::RDoc::RI::Paths::SITEDIR, ::RDoc::RI::Paths::HOMEDIR ].find_all do |p|
+    p && File.directory?(p)
+  end
+  FastRI::Util.gem_directories_unique.each do |name, version, path|
+    paths << path
+    puts "Indexing RI docs for #{name} version #{version || "unknown"}."
+  end
+
+  puts "Building index."
+  t0 = Time.new
+  #ri_reader = RI::RiReader.new(RI::RiCache.new(paths))
+  ri_reader = FastRI::RiIndex.new_from_paths(paths)
+  open(index_file, "wb"){|io| Marshal.dump ri_reader, io}
+  puts <<EOF
+Indexed:
+* #{ri_reader.num_methods} methods
+* #{ri_reader.num_namespaces} classes/modules
+Needed #{Time.new - t0} seconds
+EOF
+  ri_reader
+end
+
+def linearize(comment)
+  case s = comment["body"]
+  when String; s
+  else 
+    if Array === (y = comment["contents"])
+      y.map{|z| linearize(z)}.join("\n")
+    elsif s = comment["text"]
+      s
+    else
+      nil
+    end
+  end
+end
+
+def make_full_text_index(dir)
+  paths = [ RI::Paths::SYSDIR, RI::Paths::SITEDIR, RI::Paths::HOMEDIR ].find_all do |p|
+    p && File.directory?(p)
+  end
+  FastRI::Util.gem_directories_unique.each do |name, version, path|
+    paths << path
+    puts "Indexing RI docs for #{name} version #{version || "unknown"}."
+  end
+  unless File.exist?(dir)
+    Dir.mkdir(dir)
+  end
+  indexer = FastRI::FullTextIndexer.new(40)
+  bad = 0
+  paths.each do |path|
+    Dir["#{path}/**/*.yaml"].each do |yamlfile|
+      yaml = File.read(yamlfile)
+      begin
+        data = YAML.load(yaml.gsub(/ \!.*/, ''))
+      rescue Exception
+        bad += 1
+        #puts "Couldn't load #{yamlfile}"
+        next
+      end
+
+      desc = (data['comment']||[]).map{|x| linearize(x)}.join("\n")
+      desc.gsub!(/<\/?(em|b|tt|ul|ol|table)>/, "")
+      desc.gsub!(/&quot;/, "'")
+      desc.gsub!(/&lt;/, "<")
+      desc.gsub!(/&gt;/, ">")
+      desc.gsub!(/&amp;/, "&")
+      unless desc.empty?
+        indexer.add_document(yamlfile, desc) 
+      end
+    end
+  end
+
+  File.open(File.join(dir, "full_text.dat"), "wb") do |fulltextIO|
+    File.open(File.join(dir, "suffixes.dat"), "wb") do |suffixesIO|
+      indexer.build_index(fulltextIO, suffixesIO)
+    end
+  end
+end
+
+#{{{ Main program
+
+require 'optparse'
+
+home = FastRI::Util.find_home
+options = {:allowed_hosts => ["127.0.0.1"], :addr => "127.0.0.1",
+  :index_file => File.join(home, ".fastri-index"),
+  :do_full_text => false, 
+  :full_text_dir => File.join(home, ".fastri-fulltext"),
+}
+OptionParser.new do |opts|
+  opts.version = FastRI::FASTRI_VERSION
+  opts.release = FastRI::FASTRI_RELEASE_DATE
+  opts.banner = "Usage: fastri-server.rb [options]"
+
+  opts.on("-a", "--allow HOST", "Allow connections from HOST.",
+          "(default: 127.0.0.1)") do |host|
+    options[:allowed_hosts] << host
+  end
+
+  opts.on("-s", "--bind ADDR", "Listen to connections on ADDR.",
+          "(default: 127.0.0.1)") do |addr|
+    options[:addr] = addr
+  end
+
+  opts.on("--index-file=FILE", "Use index file.",
+          "(default: #{options[:index_file]})") do |file|
+    options[:index_file] = file
+  end
+
+  opts.on("-b", "--rebuild-index", "Only rebuild index.") do 
+    make_index(options[:index_file])
+    exit 0
+  end
+
+  opts.on("-F", "--full-text-dir DIR", "Place full-text index in DIR",
+          "(default: #{options[:full_text_dir]})") do |dir|
+    options[:full_text_dir] = dir if dir
+    options[:do_full_text]  = true
+  end
+
+  opts.on("-B", "--rebuild-full-text", "Rebuild full-text index.") do
+    make_full_text_index(options[:full_text_dir])
+    exit 0
+  end
+
+  opts.on("-h", "--help", "Show this help message") do 
+    puts opts
+    exit
+  end
+end.parse!
+
+if File.exist?(options[:index_file])
+  ri_reader = open(options[:index_file], "rb"){|io| Marshal.load io } rescue nil
+end
+
+ri_reader ||= make_index(options[:index_file])
+
+service = FastRI::RiService.new(ri_reader)
+GC.start
+
+require 'rinda/ring'
+require 'rinda/tuplespace'
+require 'drb/acl'
+
+class FastRI::RiService
+  include DRbUndumped
+end
+
+#{{{ start DRb service
+acl_opt = ["deny", "all"]
+options[:allowed_hosts].each{|host| acl_opt.concat ["allow", host.strip]}
+acl = ACL.new(acl_opt)
+DRb.install_acl(acl)
+
+ip   = options[:addr][/^[^:]+/]    || "127.0.0.1"
+port = options[:addr][/:(\d+)/, 1] || 0
+drb_addr = "druby://#{ip}:#{port}"
+DRb.start_service(drb_addr)
+
+$SAFE = 1
+
+$stdout.sync = true
+begin
+  puts "Looking for Ring server..."
+  finder = Rinda::RingFinger.new
+  service_ts = finder.lookup_ring_any(2)
+  puts "Located Ring server at #{service_ts.__drburi}"
+rescue Exception
+  puts "No Ring server found, starting my own."
+  service_ts = Rinda::TupleSpace.new
+  ring_server = Rinda::RingServer.new(service_ts)
+end
+
+begin
+  service_ts.write([:name, :FastRI, service, 'FastRI documentation'], Rinda::SimpleRenewer.new)
+rescue Exception
+  puts <<EOF
+The FastRI service could not be registered in the Ring.
+This is probably due to the Ring being bound to an unreachable address.
+You can specify which address the Ring should be bound to with
+  fastri-server --bind ADDRESS --allow ADDRESS
+EOF
+  exit
+end
+
+# {{{ Init message
+puts "fastri-server #{FASTRI_SERVER_VERSION} (FastRI #{FastRI::FASTRI_VERSION}) listening on #{DRb.uri}"
+puts "ACL:"
+acl_opt.each_slice(2){|action, host| puts "%-5s %s" % [action, host]}
+
+# {{{ GC periodically
+# keeps the process hot too :)
+Thread.new do 
+  loop do
+    GC.start
+    sleep 300
+  end
+end
+
+if $DEBUG
+  # trying to see where our memory is going
+  population = Hash.new{|h,k| h[k] = [0,0]}
+  array_sizes = Hash.new{|h,k| h[k] = 0}
+  ObjectSpace.each_object do |object|
+    size = case object   # rough estimates
+           when Array
+             array_sizes[object.size / 10] += 1
+             case object.size
+             when 0..16
+               20 + 64
+             else
+               20 + 4 * object.size * 1.5
+             end
+           when Hash;    40 + 4 * [object.size / 5, 11].max + 16 * object.size
+           when String;  30 + object.size
+           else 120 # the iv_tbl, etc
+           end
+    count, tsize = population[object.class] 
+    population[object.class] = [count + 1, tsize + size]
+  end
+
+  population.sort_by{|k,(c,s)| s}.reverse[0..10].each do |klass, (count, bytes)|
+    puts "%-20s  %7d  %9d" % [klass, count, bytes]
+  end
+
+  puts "Array sizes:"
+  array_sizes.sort.each{|k,v| puts "%5d  %6d" % [k * 10, v]}
+end
+
+DRb.thread.join
+
+# vi: set sw=2 expandtab:

data/bin/fri

@@ -0,0 +1,353 @@
+#!/usr/bin/env ruby
+# fri: access RI documentation through DRb
+# Copyright (C) 2006 Mauricio Fernandez <mfp@acm.org>
+#
+
+require 'fastri/util'
+require 'fastri/full_text_index'
+
+default_local_mode = File.basename($0)[/^qri/] ? true : false
+
+# we bind to 127.0.0.1 by default, because otherwise Ruby will try with
+# 0.0.0.0, which results in a DNS request, adding way too much latency
+options = {
+  :addr   => "127.0.0.1",
+  :format =>
+    case RUBY_PLATFORM
+    when /win/
+      if /darwin|cygwin/ =~ RUBY_PLATFORM
+        "ansi"
+      else
+        "plain"
+      end
+    else
+      "ansi"
+    end,
+  :width => 72,
+  :lookup_order => [
+    :exact, :exact_ci, :nested, :nested_ci, :partial, :partial_ci, 
+    :nested_partial, :nested_partial_ci,
+  ],
+  :show_matches => false,
+  :do_full_text => false, 
+  :full_text_dir => File.join(FastRI::Util.find_home, ".fastri-fulltext"),
+  :use_pager => nil,
+  :pager => nil,
+  :list_classes => nil,
+  :list_methods => nil,
+  :extended => false,
+  :index_file => File.join(FastRI::Util.find_home, ".fastri-index"),
+  :local_mode => default_local_mode,
+  :do_second_guess => true,
+  :expand_choices => false,
+}
+
+override_addr_env = false
+
+
+# only load optparse if actually needed
+# saves ~0.01-0.04s.
+if (arg = ARGV[0]) && arg[0, 1] == "-" or ARGV.empty?
+  require 'optparse'
+  optparser = OptionParser.new do |opts|
+    opts.version = FastRI::FASTRI_VERSION
+    opts.release = FastRI::FASTRI_RELEASE_DATE
+    opts.banner = "Usage: #{File.basename($0)} [options] <query>"
+
+    opts.on("-L", "--local", "Try to use local index instead of DRb service.",
+                             *[("(default)" if default_local_mode)].compact) do
+      options[:local_mode] = true
+    end
+    opts.on("--index-file=FILE", "Use index file (forces --local mode).",
+            "(default: #{options[:index_file]})") do |file|
+      options[:index_file] = file
+      options[:local_mode] = true
+    end
+    opts.on("-R", "--remote", "Use DRb service. #{'(default)' unless default_local_mode}") do
+      options[:local_mode] = false
+    end
+    opts.on("-s", "--bind ADDR", "Bind to ADDR for incoming DRb connections.",
+            "(default: 127.0.0.1)") do |addr|
+      options[:addr] = addr
+      override_addr_env = true
+    end
+
+    order_mapping = {
+      'e' => :exact,   'E' => :exact_ci,   'n' => :nested, 'N' => :nested_ci,
+      'p' => :partial, 'P' => :partial_ci, 'x' => :nested_partial,
+      'X' => :nested_partial_ci, 'a' => :anywhere, 'A' => :anywhere_ci,
+      'm' => :namespace_partial, 'M' => :namespace_partial_ci,
+      'f' => :full_partial, 'F' => :full_partial_ci,
+    }
+    opts.on("-O", "--order ORDER", "Specify lookup order.",
+            "(default: eEnNpPxX)", "Uppercase: case-indep.",
+            "e:exact n:nested p:partial (completion)",
+            "x:nested and partial m:complete namespace",
+            "f:complete both class and method",
+            "a:match method name anywhere") do |order|
+      options[:lookup_order] = order.split(//).map{|x| order_mapping[x]}.compact
+    end
+
+    opts.on("-1", "--exact", "Does not do second guess(exact query).") do
+      options[:do_second_guess] = false
+      options[:lookup_order] = [ :exact ]
+    end
+    opts.on("-a", "--all", "Show info for all methods in Multiple choices",
+            "(default: don't)") do
+      options[:expand_choices] = true
+    end
+
+    opts.on("-e", "--extended", "Show all methods for given namespace.") do
+      options[:extended]  = true
+      options[:use_pager] = true
+      options[:format]    = "plain"
+    end
+
+    opts.on("--show-matches", "Only show matching entries."){ options[:show_matches] = true }
+
+    opts.on("--classes", "List all known classes/modules.") do 
+      options[:use_pager]    = true
+      options[:list_classes] = true
+    end
+    opts.on("--methods", "List all known methods.") do 
+      options[:use_pager]    = true
+      options[:list_methods] = true
+    end
+    opts.on("-l", "--list-names", "List all known namespaces/methods.") do
+      options[:use_pager]    = true
+      options[:list_classes] = true
+      options[:list_methods] = true
+    end
+
+    opts.on("-S", "--full-text", "Perform full-text search.") do 
+      options[:do_full_text] = true
+      options[:use_pager]    = true if options[:use_pager].nil?
+      options[:format]       = "plain"
+    end
+
+    opts.on("-F", "--full-text-dir DIR", "Use full-text index in DIR",
+            "(default: #{options[:full_text_dir]})") do |dir|
+      options[:full_text_dir] = dir if dir
+      options[:do_full_text]  = true
+      options[:use_pager]     = true
+      options[:format]        = "plain"
+    end
+
+    opts.on("-f", "--format FMT", "Format to use when displaying output:",
+            "   ansi, plain (default: #{options[:format]})") do |format|
+      options[:format] = format
+    end
+
+    opts.on("-P", "--[no-]pager", "Use pager.", "(default: don't)") do |usepager|
+      options[:use_pager] = usepager
+      options[:format] = "plain" if usepager
+    end
+
+    opts.on("-T", "Don't use a pager."){ options[:use_pager] = false }
+
+    opts.on("--pager-cmd PAGER", "Use pager PAGER.", "(default: don't)") do |pager|
+      options[:pager]     = pager
+      options[:use_pager] = true
+      options[:format]    = "plain"
+    end
+
+    opts.on("-w", "--width WIDTH", "Set the width of the output.") do |width|
+      w = width.to_i
+      options[:width] = w > 0 ? w : options[:width]
+    end
+
+    opts.on("-h", "--help", "Show this help message") do 
+      puts opts
+      exit
+    end
+  end
+  optparser.parse!
+
+  if !options[:list_classes] && !options[:list_methods] && ARGV.empty?
+    puts optparser
+    exit
+  end
+end # lazy optparse loading
+
+# {{{ try to find where the method comes from exactly
+include FastRI::Util::MagicHelp
+
+MAX_CONTEXT_LINES = 20
+def context_wrap(text, width)
+  "... " + 
+  text.gsub(/(.{1,#{width-4}})( +|$\n?)|(.{1,#{width-4}})/, "\\1\\3\n").chomp
+end
+
+def display_fulltext_search_results(results, gem_dir_info = FastRI::Util.gem_directories_unique,
+                                    width = 78)
+  return if results.empty?
+  path = File.expand_path(results[0].path)
+  gem_name, version, gem_path = FastRI::Util.gem_info_for_path(path, gem_dir_info)
+  if gem_name
+    rel_path = path[/#{Regexp.escape(gem_path)}\/(.*)/, 1]
+    if rel_path
+      entry_name = FastRI::Util.gem_relpath_to_full_name(rel_path)
+    end
+    puts "Found in #{gem_name} #{version}  #{entry_name}"
+  else
+    rdoc_system_path = File.expand_path(RI::Paths::SYSDIR)
+    if path.index(rdoc_system_path)
+      rel_path = path[/#{Regexp.escape(rdoc_system_path)}\/(.*)/, 1]
+      puts "Found in system  #{FastRI::Util.gem_relpath_to_full_name(rel_path)}"
+    else
+      puts "Found in #{path}:"
+    end
+  end
+  text = results.map do |result|
+    context = result.context(120)
+    from = (context.rindex("\n", context.index(result.query)) || -1) + 1
+    to   = (context.index("\n", context.index(result.query)) || 0) - 1
+    context_wrap(context[from..to], width)
+  end
+  puts
+  puts text.uniq[0...MAX_CONTEXT_LINES]
+  puts
+end
+
+def perform_fulltext_search(options)
+  fulltext = File.join(options[:full_text_dir], "full_text.dat")
+  suffixes = File.join(options[:full_text_dir], "suffixes.dat")
+  begin
+    index = FastRI::FullTextIndex.new_from_filenames(fulltext, suffixes)
+  rescue Exception
+    puts <<EOF
+Couldn't open the full-text index:
+#{fulltext}
+#{suffixes}
+
+The index needs to be rebuilt with
+   fastri-server -B
+EOF
+    exit(-1)
+  end
+  gem_dir_info = FastRI::Util.gem_directories_unique
+  match_sets = ARGV.map do |query|
+    result = index.lookup(query)
+    if result
+      index.next_matches(result) + [result]
+    else
+      []
+    end
+  end
+  path_map = Hash.new{|h,k| h[k] = []}
+  match_sets.each{|matches| matches.each{|m| path_map[m.path] << m} }
+  paths = match_sets[1..-1].inject(match_sets[0].map{|x| x.path}.uniq) do |s,x|
+    s & x.map{|y| y.path}.uniq
+  end
+  if paths.empty?
+    puts "nil"
+  else
+    puts "#{paths.size} hits"
+    paths.sort_by{|path| 1.0 * -path_map[path].size / path_map[path].first.metadata[:size] ** 0.5}.map do |path|
+      puts "=" * options[:width]
+      puts 1.0 * path_map[path].size / path_map[path].first.metadata[:size] ** 0.5
+      display_fulltext_search_results(path_map[path], gem_dir_info, options[:width])
+    end
+  end
+  
+  exit 0
+end
+
+#{{{ set up pager
+if options[:use_pager]
+  [options[:pager], ENV["PAGER"], "less", "more", "pager"].compact.uniq.each do |pager|
+    begin
+      $stdout = IO.popen(pager, "w")
+      at_exit{ $stdout.close }
+      break
+    rescue Exception
+    end
+  end
+end
+
+#{{{ perform full text search if asked to
+perform_fulltext_search(options) if options[:do_full_text]
+
+#{{{ normal query
+if options[:local_mode]
+  require 'fastri/ri_service'
+  ri_reader = open(options[:index_file], "rb"){|io| Marshal.load io } rescue nil
+  unless ri_reader
+    puts <<EOF
+Couldn't open the index:
+#{options[:index_file]}
+
+The index needs to be rebuilt with
+   fastri-server -b
+EOF
+    exit(-1)
+  end
+  service = FastRI::RiService.new(ri_reader)
+else # remote
+  require 'rinda/ring'
+
+  #{{{ determine the address to bind to
+  if override_addr_env
+    addr_spec = options[:addr]
+  else
+    addr_spec = ENV["FASTRI_ADDR"] || options[:addr]
+  end
+
+  ip   = addr_spec[/^[^:]+/]    || "127.0.0.1"
+  port = addr_spec[/:(\d+)/, 1] || 0
+  addr = "druby://#{ip}:#{port}"
+
+  #{{{ start DRb and perform request
+  begin
+    DRb.start_service(addr)
+    ring_server = Rinda::RingFinger.primary
+  rescue Exception
+    $stderr.puts <<EOF
+Couldn't initialize DRb and locate the Ring server.
+
+Please make sure that:
+ * the fastri-server is running, the server is bound to the correct interface,
+   and the ACL setup allows connections from this host
+ * fri is using the correct interface for incoming DRb requests:
+   either set the FASTRI_ADDR environment variable, or use --bind ADDR, e.g
+      export FASTRI_ADDR="192.168.1.12"
+      fri Array
+EOF
+    exit(-1)
+  end
+  service = ring_server.read([:name, :FastRI, nil, nil])[2]
+end
+
+
+info_options = {
+  :formatter => options[:format],
+  :width     => options[:width],
+  :lookup_order => options[:lookup_order],
+  :extended  => options[:extended],
+  :expand_choices => options[:expand_choices],
+}
+
+# {{{ list classes or methods
+puts service.all_classes if options[:list_classes]
+puts service.all_methods if options[:list_methods]
+exit if options[:list_classes] || options[:list_methods]
+
+# {{{ normal query
+
+ARGV.each do |term|
+  help_query = magic_help(term)
+  if options[:show_matches]
+    puts service.matches(help_query, info_options).sort
+  else
+    result = service.info(help_query, info_options)
+    # second-guess the correct method type only as the last resort.
+    if result
+      puts result
+    elsif options[:do_second_guess] and (new_query = FastRI::Util.change_query_method_type(help_query)) != help_query
+      puts service.info(new_query)
+    else
+      puts nil
+    end
+  end
+end
+# vi: set sw=2 expandtab: