fastri 0.2.1.1 → 0.3.0.1

data/CHANGES

@@ -1,6 +1,19 @@
 
 User-visible changes in FastRI
 
+Since version 0.2.1 (2006-11-23)
+================================
+Features
+--------
+* get all the information about a class/module and its methods with --extended
+* new search methods: complete namespace (-Om), partial completion on both
+  namespace and method name (-Of), and case-indep. variants.
+* --local (-L) and --remote (-L) (default) options. --local makes fri operate
+  in standalone mode, without requiring fastri-server.
+* new executable: qri, equivalent to fri -L (local, standalone mode)
+* try to second-guess the correct method type if all search methods fail
+  and the type was explicitly given
+
 Since version 0.2.0 (2006-11-15)
 ================================
 Features

data/Rakefile

@@ -29,7 +29,7 @@ require 'fastri/version'
 
 PKG_REVISION = ".1"
 PKG_FILES = FileList[
-"bin/fri", "bin/fastri-server", "bin/ri-emacs",
+"bin/fri", "bin/qri", "bin/fastri-server", "bin/ri-emacs",
 "lib/**/*.rb", "CHANGES",
 "COPYING", "LEGAL", "LICENSE", "Rakefile", "README.*", "test/*.rb",
 "setup.rb", "pre-install.rb", 
@@ -54,7 +54,7 @@ EOF
   s.email = "mfp@acm.org"
   s.homepage = "http://eigenclass.org/hiki.rb?fastri"
   s.bindir = "bin"
-  s.executables = %w[fri fastri-server ri-emacs]
+  s.executables = %w[fri qri fastri-server ri-emacs]
   s.has_rdoc = true
   #s.extra_rdoc_files = %w[]
   s.rdoc_options << "--title" << 'FastRI: better, faster ri'
@@ -93,4 +93,10 @@ Rake::GemPackageTask.new(Spec) do |p|
   p.need_tar = true
 end
 
+file "bin/qri" => %w[bin/fri] do
+  cp "bin/fri", "bin/qri"
+end
+
+task :gem => ["bin/qri"]
+
 # vim: set sw=2 ft=ruby:

data/bin/fastri-server

@@ -107,6 +107,8 @@ options = {:allowed_hosts => ["127.0.0.1"], :addr => "127.0.0.1",
   :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.",

data/bin/fri

@@ -7,6 +7,8 @@ require 'optparse'
 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 = {
@@ -34,11 +36,30 @@ options = {
   :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,
 }
+
 override_addr_env = false
+
 optparser = OptionParser.new do |opts|
-  opts.banner = "Usage: fri [options] <query>"
+  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
@@ -49,15 +70,24 @@ optparser = OptionParser.new do |opts|
     '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",
+          "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("-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 
@@ -124,39 +154,7 @@ if !options[:list_classes] && !options[:list_methods] && ARGV.empty?
 end
 
 # {{{ try to find where the method comes from exactly
-def help_method_extract(m) # :nodoc:
-  unless m.inspect =~ %r[\A#<(?:Unbound)?Method: (.*?)>\Z]
-    raise "Cannot parse result of #{m.class}#inspect: #{m.inspect}"
-  end
-  $1.sub(/\A.*?\((.*?)\)(.*)\Z/){ "#{$1}#{$2}" }.sub(/\./, "::").sub(/#<Class:(.*?)>#/) { "#{$1}::" }
-end
-
-def magic_help(query)
-  if query =~ /\A(.*?)(#|::|\.)(.*)\Z/
-    c, k, m = $1, $2, $3
-    begin
-      c = Object.const_get(c)
-      m = case k
-      when "#"
-        c.instance_method(m)
-      when "::"
-        c.method(m)
-      when "."
-        begin
-          c.method(m)
-        rescue NameError
-          c.instance_method(m)
-        end
-      end
-      help_method_extract(m)
-    rescue Exception
-      query
-    end
-  else
-    query
-  end
-end
-
+include FastRI::Util::MagicHelp
 
 MAX_CONTEXT_LINES = 20
 def context_wrap(text, width)
@@ -255,26 +253,40 @@ end
 perform_fulltext_search(options) if options[:do_full_text]
 
 #{{{ normal query
-require 'rinda/ring'
+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
+  #{{{ 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}"
+  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
+  #{{{ 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:
@@ -285,13 +297,17 @@ Please make sure that:
       export FASTRI_ADDR="192.168.1.12"
       fri Array
 EOF
-  exit(-1)
+    exit(-1)
+  end
+  service = ring_server.read([:name, :FastRI, nil, nil])[2]
 end
-service = ring_server.read([:name, :FastRI, nil, nil])[2]
+
+
 info_options = {
   :formatter => options[:format],
   :width     => options[:width],
   :lookup_order => options[:lookup_order],
+  :extended  => options[:extended],
 }
 
 # {{{ list classes or methods
@@ -306,7 +322,15 @@ ARGV.each do |term|
   if options[:show_matches]
     puts service.matches(help_query, info_options).sort
   else
-    puts service.info(help_query, info_options)
+    result = service.info(help_query, info_options)
+    # second-guess the correct method type only as the last resort.
+    if result
+      puts result
+    elsif (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:

data/bin/qri

@@ -0,0 +1,336 @@
+#!/usr/bin/env ruby
+# fri: access RI documentation through DRb
+# Copyright (C) 2006 Mauricio Fernandez <mfp@acm.org>
+#
+
+require 'optparse'
+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,
+}
+
+override_addr_env = false
+
+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("-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
+
+# {{{ 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],
+}
+
+# {{{ 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 (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:

data/bin/ri-emacs

@@ -24,6 +24,7 @@
 
 require 'rinda/ring'
 require 'optparse'
+require 'fastri/util'
 
 # {{{ cmdline parsing and service discovery
 # we bind to 127.0.0.1 by default, because otherwise Ruby will try with
@@ -67,11 +68,13 @@ Please make sure that:
       export FASTRI_ADDR="192.168.1.12"
       fri Array
 EOF
-  exit(-1)
+  exit(-1)                      # '
 end
 service = ring_server.read([:name, :FastRI, nil, nil])[2]
 
 class EventLoop
+  include FastRI::Util::MagicHelp
+
   def initialize(ri)
     @ri = ri
   end
@@ -167,16 +170,22 @@ class EventLoop
     end
   end
 
-  def display_args(keyw)
-    data = @ri.args(keyw)
-    puts data if data
+  def display_(what, keyw)
+    data = @ri.__send__(what, magic_help(keyw))
+    if data
+      puts data
+    elsif (new_keyw = FastRI::Util.change_query_method_type(keyw)) != keyw
+      puts @ri.__send__(what, new_keyw)
+    end
     puts "RI_EMACS_END_OF_INFO"
   end
 
+  def display_args(keyw)
+    display_ :args, keyw
+  end
+
   def display_info(keyw)
-    data = @ri.info(keyw)
-    puts data if data
-    puts "RI_EMACS_END_OF_INFO"
+    display_ :info, keyw
   end
 end
 

data/lib/fastri/ri_index.rb

@@ -534,7 +534,7 @@ class RiIndex
     if prefix.empty?
       [//, /^[#.] /]  # the second should never match
     else
-      [/^#{Regexp.escape(prefix)}/, /^#{Regexp.escape(prefix)}([#.])\S+ / ]
+      [/^#{Regexp.escape(prefix)}([#.]|::)/, /^#{Regexp.escape(prefix)}([#.])\S+ / ]
     end
   end
 

data/lib/fastri/ri_service.rb

@@ -180,6 +180,7 @@ class RiService
   DEFAULT_INFO_OPTIONS = {
     :formatter => :ansi,
     :width     => 72,
+    :extended  => false,
   }
 
   def matches(keyword, options = {})
@@ -205,6 +206,12 @@ class RiService
       when :namespace
         capture_stdout(display(options)) do |display|
           display.display_class_info(@ri_reader.get_class(entries[0]), @ri_reader)
+          if options[:extended]
+            methods = @ri_reader.methods_under(entries[0], true)
+            methods.each do |meth_entry|
+              display.display_method_info(@ri_reader.get_method(meth_entry))
+            end
+          end
         end
       when :method
         capture_stdout(display(options)) do |display|
@@ -269,6 +276,7 @@ class RiService
   private
 
   def obtain_unqualified_method_entries(name, separators, order)
+    name = Regexp.escape(name)
     sep_re = "(" + separators.map{|x| Regexp.escape(x)}.join("|") + ")"
     matcher = MatchFinder.new do |m|
       m.add_matcher(:exact) do
@@ -294,6 +302,8 @@ class RiService
   end
 
   def obtain_qualified_method_entries(namespace, method, separators, order)
+    namespace, unescaped_namespace = Regexp.escape(namespace), namespace
+    method = Regexp.escape(method)
     matcher = MatchFinder.new do |m|
       m.add_matcher(:exact) do
         separators.each do |sep|
@@ -311,7 +321,7 @@ class RiService
         m.yield @ri_reader.methods_under_matching("", /::#{namespace}#{sep_re}#{method}$/i, true)
       end
       m.add_matcher(:partial) do
-        m.yield @ri_reader.methods_under_matching(namespace, /#{sep_re}#{method}/, false)
+        m.yield @ri_reader.methods_under_matching(unescaped_namespace, /#{sep_re}#{method}/, false)
       end
       m.add_matcher(:partial_ci) do
         m.yield @ri_reader.methods_under_matching("", /^#{namespace}#{sep_re}#{method}/i, true)
@@ -322,11 +332,24 @@ class RiService
       m.add_matcher(:nested_partial_ci) do
         m.yield @ri_reader.methods_under_matching("", /::#{namespace}#{sep_re}#{method}/i, true)
       end
+      m.add_matcher(:namespace_partial) do
+        m.yield @ri_reader.methods_under_matching("", /^#{namespace}[^:]*#{sep_re}#{method}$/, true)
+      end
+      m.add_matcher(:namespace_partial_ci) do
+        m.yield @ri_reader.methods_under_matching("", /^#{namespace}[^:]*#{sep_re}#{method}$/i, true)
+      end
+      m.add_matcher(:full_partial) do
+        m.yield @ri_reader.methods_under_matching("", /^#{namespace}[^:]*#{sep_re}#{method}/, true)
+      end
+      m.add_matcher(:full_partial_ci) do
+        m.yield @ri_reader.methods_under_matching("", /^#{namespace}[^:]*#{sep_re}#{method}/i, true)
+      end
     end
     matcher.get_matches(order)
   end
 
   def obtain_namespace_entries(name, order)
+    name = Regexp.escape(name)
     matcher = MatchFinder.new do |m|
       m.add_matcher(:exact){ m.yield @ri_reader.get_class_entry(name) }
       m.add_matcher(:exact_ci) do 

data/lib/fastri/util.rb

@@ -96,5 +96,74 @@ module Util
     end
   end
   module_function :find_home
+
+  def change_query_method_type(query)
+    if md = /\A(.*)(#|\.|::)([^#.:]+)\z/.match(query)
+      namespace, sep, meth = md.captures
+      case sep
+      when /::/ then "#{namespace}##{meth}"
+      when /#/ then "#{namespace}::#{meth}"
+      else 
+        query
+      end
+    else
+      query
+    end
+  end
+  module_function :change_query_method_type
+
+
+  module MagicHelp
+    def help_method_extract(m) # :nodoc:
+      unless m.inspect =~ %r[\A#<(?:Unbound)?Method: (.*?)>\Z]
+        raise "Cannot parse result of #{m.class}#inspect: #{m.inspect}"
+      end
+      $1.sub(/\A.*?\((.*?)\)(.*)\Z/){ "#{$1}#{$2}" }.sub(/\./, "::").sub(/#<Class:(.*?)>#/) { "#{$1}::" }
+    end
+
+    def magic_help(query)
+      if query =~ /\A(.*?)(#|::|\.)([^:#.]+)\Z/
+        c, k, m = $1, $2, $3
+        mid = m
+        begin
+          c = c.split(/::/).inject(Object){|s,x| s.const_get(x)}
+          m = case k
+              when "#"
+                c.instance_method(m)
+              when "::"
+                c.method(m)
+              when "."
+                begin
+                  # if it's a private_instance_method, assume it was created
+                  # with module_function
+                  if c.private_instance_methods.include?(m)
+                    c.instance_method(m)
+                  else
+                    c.method(m)
+                  end
+                rescue NameError
+                  c.instance_method(m)
+                end
+              end
+
+          ret = help_method_extract(m)
+          if ret == 'Class#new' and
+              c.private_method_defined?(:initialize)
+            return c.name + "::new"
+          elsif ret =~ /^Kernel#/ and
+              Kernel.instance_methods(false).include? mid
+            return "Object##{mid}"
+          end
+          ret
+        rescue Exception
+          query
+        end
+      else
+        query
+      end
+    end
+  end
+
+
 end # module Util
 end # module FastRI

data/lib/fastri/version.rb

@@ -2,8 +2,8 @@
 #
 
 module FastRI
-  FASTRI_VERSION      = "0.2.1"
-  FASTRI_RELEASE_DATE = "2006-11-23"
+  FASTRI_VERSION      = "0.3.0"
+  FASTRI_RELEASE_DATE = "2007-01-29"
   FASTRI_INDEX_FORMAT = "0.1.0"
   FASTRI_FT_INDEX_FORMAT = "1.0.0"
   FASTRI_FT_INDEX_FORMAT_MAJOR = "1"

data/pre-install.rb

@@ -1,8 +1,11 @@
 #!/usr/bin/env ruby
+require 'fileutils'
+
+FileUtils.cp "bin/fri", "bin/qri"
 
 if /win/ =~ RUBY_PLATFORM and /darwin|cygwin/ !~ RUBY_PLATFORM
-  require 'fileutils'
-  %w[fri fastri-server ri-emacs].each do |fname|
+  %w[fri qri fastri-server ri-emacs].each do |fname|
     FileUtils.mv "bin/#{fname}", "bin/#{fname}.rb", :force => true
   end
 end
+

data/test/test_ri_index.rb

@@ -29,11 +29,30 @@ ABC::Zzz#foo 0
 CDE.foo 1 2
 FGH::Adfdsf#foo 2
 ================================================================================
+EOF
+  INDEX_DATA2 =<<EOF
+#{FastRI::RiIndex::MAGIC}
+Sources:
+system                          /usr/share/ri/system/
+somegem-0.1.0                   /long/path/somegem-0.1.0
+stuff-1.1.0                     /long/path/stuff-1.1.0
+================================================================================
+Namespaces:
+ABC 0 1
+ABCDEF 1 2
+================================================================================
+Methods:
+ABC.bar 0
+ABC#baz 1
+ABCDEF#foo 1
+ABCDEF.foo 1 2
+================================================================================
 EOF
 
   require 'stringio'
   def setup
     @index = FastRI::RiIndex.new_from_IO(StringIO.new(INDEX_DATA))
+    @index2 = FastRI::RiIndex.new_from_IO(StringIO.new(INDEX_DATA2))
   end
 
   def test_dump
@@ -157,6 +176,11 @@ EOF
                  @index.source_paths_for(@index.get_method_entry("CDE.foo")))
   end
 
+  def test_methods_under_same_prefix
+    results = @index2.methods_under("ABC", true, nil)
+    results.map{|x| x.full_name}
+    assert_equal(["ABC.bar", "ABC#baz"], results.map{|x| x.full_name})
+  end
 
   def test_methods_under_scoped
     results = @index.methods_under("ABC", true, 1)

data/test/test_util.rb

@@ -35,4 +35,57 @@ EOF
     assert_equal("Foo::Bar#eql?", gem_relpath_to_full_name("Foo/Bar/eql%3f-i.yaml"))
     assert_equal("Foo::Bar.eql?", gem_relpath_to_full_name("Foo/Bar/eql%3f-c.yaml"))
   end
+
+  def test_change_query_method_type
+    assert_equal(".foo", change_query_method_type(".foo"))
+    assert_equal("::foo", change_query_method_type("#foo"))
+    assert_equal("#foo", change_query_method_type("::foo"))
+    assert_equal("A::B.foo", change_query_method_type("A::B.foo"))
+    assert_equal("A::B::foo", change_query_method_type("A::B#foo"))
+    assert_equal("A::B#foo", change_query_method_type("A::B::foo"))
+  end
+end
+
+class TestUtilMagicHelp < Test::Unit::TestCase
+  include FastRI::Util::MagicHelp
+  module TestModule
+    def foo; end
+    module_function :foo
+
+    def self.bar; end
+    def bar; end
+  end
+
+  def test_magic_help
+    assert_equal("IO::readlines", magic_help("IO::readlines"))
+    assert_equal("IO::readlines", magic_help("IO.readlines"))
+
+    assert_equal("Enumerable#inject", magic_help("File#inject"))
+    assert_equal("Enumerable#inject", magic_help("File.inject"))
+
+    assert_equal("IO::readlines", magic_help("File.readlines"))
+    assert_equal("IO::readlines", magic_help("File::readlines"))
+  end
+
+  def test_magic_help_nested_namespaces
+    assert_equal("TestUtilMagicHelp::TestModule#foo", 
+                 magic_help("TestUtilMagicHelp::TestModule.foo"))
+    assert_equal("TestUtilMagicHelp::TestModule::bar", 
+                 magic_help("TestUtilMagicHelp::TestModule.bar"))
+  end
+
+  def test_magic_help__new
+    assert_equal("Array::new", magic_help("Array::new"))
+    assert_equal("Array::new", magic_help("Array.new"))
+    assert_equal("Struct::new", magic_help("Struct.new"))
+    assert_equal("Struct::new", magic_help("Struct::new"))
+  end
+
+  def test_magic_help__Kernel_public_instance_methods
+    # It is mysterious.
+    # Object.instance_method(:object_id) # => #<UnboundMethod: Object(Kernel)#object_id>
+    assert_equal("Object#object_id", magic_help("Object.object_id"))
+    assert_equal("Object#object_id", magic_help("Object#object_id"))
+  end
+
 end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: fastri
 version: !ruby/object:Gem::Version 
-  version: 0.2.1.1
-date: 2006-11-23 00:00:00 +01:00
+  version: 0.3.0.1
+date: 2007-01-29 00:00:00 +01:00
 summary: RI docs across machines, faster and smarter than ri.
 require_paths: 
 - lib
@@ -55,6 +55,7 @@ authors:
 - Mauricio Fernandez
 files: 
 - bin/fri
+- bin/qri
 - bin/fastri-server
 - bin/ri-emacs
 - lib/fastri/ri_index.rb
@@ -94,6 +95,7 @@ extra_rdoc_files: []
 
 executables: 
 - fri
+- qri
 - fastri-server
 - ri-emacs
 extensions: []