fastri 0.1.0.1 → 0.1.1.1

data/CHANGES

@@ -0,0 +1,19 @@
+
+User-visible changes in FastRI
+
+Since version 0.1.0 (2006-11-08)
+================================
+Features
+--------
+* the search strategy can be specified with --order 
+* added case-insensitive search strategies
+* --show-matches returns a list of matching entries
+* default output format defaults to 'plain' on win32
+
+Bugfixes
+--------
+* the home directory is detected correctly on win32
+* no more SecurityErrors due to calls to #require after $SAFE=1
+* index creation doesn't bomb when RubyGems is not installed
+* executables are added the .rb extension when installing on win32 with
+  setup.rb

data/Rakefile

@@ -30,9 +30,9 @@ require 'fastri/version'
 PKG_REVISION = ".1"
 PKG_FILES = FileList[
 "bin/fri", "bin/fastri-server", "bin/ri-emacs",
-"lib/**/*.rb",
+"lib/**/*.rb", "CHANGES",
 "COPYING", "LEGAL", "LICENSE", "Rakefile", "README.*", "test/*.rb",
-"setup.rb", 
+"setup.rb", "pre-install.rb", 
 ]
 
 require 'rake/gempackagetask'

data/bin/fastri-server

@@ -1,10 +1,11 @@
-#!/usr/bin/env ruby
+#! /home/batsman/usr//bin/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 'enumerator'
 
 FASTRI_SERVER_VERSION = "0.0.1"
 
@@ -51,12 +52,31 @@ EOF
   ri_reader
 end
 
+# stolen from RubyGems
+def find_home
+  ['HOME', 'USERPROFILE'].each do |homekey|
+    return ENV[homekey] if ENV[homekey]
+  end
+  if ENV['HOMEDRIVE'] && ENV['HOMEPATH']
+    return "#{ENV['HOMEDRIVE']}:#{ENV['HOMEPATH']}"
+  end
+  begin
+    File.expand_path("~")
+  rescue StandardError => ex
+    if File::ALT_SEPARATOR
+      "C:/"
+    else
+      "/"
+    end
+  end
+end
+
 #{{{ Main program
 
 require 'optparse'
 
 options = {:allowed_hosts => ["127.0.0.1"], :addr => "127.0.0.1",
-  :index_file => File.expand_path("~/.fastri-index")}
+  :index_file => File.join(find_home, ".fastri-index")}
 OptionParser.new do |opts|
   opts.banner = "Usage: fastri-server.rb [options]"
 
@@ -139,7 +159,6 @@ EOF
 end
 
 # {{{ Init message
-require 'enumerator'
 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]}

data/bin/fri

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
+#! /home/batsman/usr//bin/ruby
 # fri: access RI documentation through DRb
 # Copyright (C) 2006 Mauricio Fernandez <mfp@acm.org>
 #
@@ -10,7 +10,23 @@ require 'optparse'
 # 0.0.0.0, which results in a DNS request, adding way too much latency
 options = {
   :addr   => "127.0.0.1",
-  :format => "ansi"
+  :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,
 }
 override_addr_env = false
 optparser = OptionParser.new do |opts|
@@ -22,11 +38,30 @@ optparser = OptionParser.new do |opts|
     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
+  }
+  opts.on("-O", "--order ORDER", "Specify lookup order.",
+          "(default: eEnNpPxX)", "Uppercase: case-indep.",
+          "e: exact, n: nested, p: partial",
+          "x: nested and partial") do |order|
+    options[:lookup_order] = order.split(//).map{|x| order_mapping[x]}.compact
+  end
+
+  opts.on("--show-matches", "Only show matching entries."){ options[:show_matches] = true }
+
   opts.on("-f", "--format FMT", "Format to use when displaying output:",
-          "   ansi, plain (default: ansi)") do |format|
+          "   ansi, plain (default: #{options[:format]})") do |format|
     options[:format] = format
   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
@@ -63,5 +98,14 @@ EOF
   exit(-1)
 end
 service = ring_server.read([:name, :FastRI, nil, nil])[2]
-puts service.info(ARGV[0], options[:format])
+info_options = {
+  :formatter => options[:format],
+  :width     => options[:width],
+  :lookup_order => options[:lookup_order],
+}
+if options[:show_matches]
+  puts service.matches(ARGV[0], info_options).sort
+else
+  puts service.info(ARGV[0], info_options)
+end
 # vi: set sw=2 expandtab:

data/bin/ri-emacs

@@ -1,4 +1,4 @@
-#!/usr/bin/env ruby
+#! /home/batsman/usr//bin/ruby
 ## drop-in replacement for the ri-emacs helper script for use 
 #  with ri-ruby.el, using the FastRI service via DRb
 #

data/lib/fastri/name_descriptor.rb

@@ -0,0 +1,71 @@
+# Copyright (C) 2006  Mauricio Fernandez <mfp@acm.org>
+#
+
+module FastRI
+
+# Alternative NameDescriptor implementation which doesn't require class/module
+# names to be properly capitalized.
+#
+# Rules:
+# * <tt>#foo</tt>: instance method +foo+
+# * <tt>.foo</tt>: method +foo+ (either singleton or instance)
+# * <tt>::foo</tt>: singleton method +foo+
+# * <tt>foo::bar#bar<tt>: instance method +bar+ under <tt>foo::bar</tt>
+# * <tt>foo::bar.bar<tt>: either singleton or instance method +bar+ under
+#   <tt>foo::bar</tt>
+# * <tt>foo::bar::Baz<tt>: module/class foo:bar::Baz
+# * <tt>foo::bar::baz</tt>: singleton method +baz+ from <tt>foo::bar</tt>
+# * other: raise RiError
+class NameDescriptor
+  attr_reader :class_names
+  attr_reader :method_name
+
+  # true and false have the obvious meaning. nil means we don't care
+  attr_reader :is_class_method
+
+  def initialize(arg)
+    @class_names = []
+    @method_name = nil
+    @is_class_method = nil
+
+    case arg
+    when /((?:[^:]*::)*[^:]*)(#|::|\.)(.*)$/
+      ns, sep, meth_or_class = $~.captures
+      # optimization attempt: try to guess the real capitalization,
+      # so we get a direct hit
+      @class_names = ns.split(/::/).map{|x|  x[0,1] = x[0,1].upcase; x }
+      if %w[# .].include? sep
+        @method_name = meth_or_class
+        @is_class_method = 
+          case sep
+          when "#";  false
+          when ".";  nil
+          end
+      else
+        if ("A".."Z").include? meth_or_class[0,1] # 1.9 compatibility
+          @class_names << meth_or_class
+        else
+          @method_name     = meth_or_class
+          @is_class_method = true
+        end
+      end
+    when /^[^#:.]+/
+      if ("A".."Z").include? arg[0,1]
+        @class_names = [arg]
+      else
+        @method_name     = arg.dup
+        @is_class_method = nil
+      end
+    else
+      raise RiError, "Cannot create NameDescriptor from #{arg}"
+    end
+  end
+
+  # Return the full class name (with '::' between the components)
+  # or "" if there's no class name
+  def full_class_name
+    @class_names.join("::")
+  end
+end
+
+end #module FastRI

data/lib/fastri/ri_index.rb

@@ -189,12 +189,17 @@ class RiIndex
     @gem_names = paths.map do |p|
       fullp = File.expand_path(p)
       gemname = nil
-      Gem.path.each do |gempath|
-        re = %r!^#{Regexp.escape(File.expand_path(gempath))}/doc/!
-        if re =~ fullp
-          gemname = fullp.gsub(re,"")[%r{^[^/]+}]
-          break
+      begin
+        require 'rubygems'
+        Gem.path.each do |gempath|
+          re = %r!^#{Regexp.escape(File.expand_path(gempath))}/doc/!
+          if re =~ fullp
+            gemname = fullp.gsub(re,"")[%r{^[^/]+}]
+            break
+          end
         end
+      rescue LoadError
+        # no RubyGems, no gems installed, skip it
       end
       gemname ? gemname : "system"
     end

data/lib/fastri/ri_service.rb

@@ -8,6 +8,8 @@ require 'rdoc/ri/ri_formatter'
 require 'rdoc/ri/ri_display'
 
 require 'fastri/ri_index.rb'
+require 'fastri/name_descriptor'
+
 
 module FastRI
 
@@ -67,57 +69,72 @@ class RedirectedTextFormatter < RI::TextFormatter
 end
 
 class RiService
+
+  class MatchFinder
+    def self.new
+      ret = super
+      yield ret if block_given?
+      ret
+    end
+
+    def initialize
+      @matchers = {}
+    end
+
+    def add_matcher(name, &block)
+      @matchers[name] = block
+    end
+
+    def get_matches(methods)
+      catch(:MatchFinder_return) do
+        methods.each do |name|
+          matcher = @matchers[name]
+          matcher.call(self) if matcher
+        end
+        []
+      end
+    end
+
+    def yield(matches)
+      case matches
+      when nil, []; nil
+      when Array
+        throw :MatchFinder_return, matches
+      else
+        throw :MatchFinder_return, [matches]
+      end
+    end
+  end # MatchFinder
+
+
   Options = Struct.new(:formatter, :use_stdout, :width)
 
   def initialize(ri_reader)
     @ri_reader = ri_reader
   end
 
-  def obtain_entries(descriptor, try_partial = true)
+  DEFAULT_OBTAIN_ENTRIES_OPTIONS = {
+    :lookup_order => [
+              :exact, :exact_ci, :nested, :nested_ci, :partial, :partial_ci, 
+              :nested_partial, :nested_partial_ci,
+    ],
+  }
+  def obtain_entries(descriptor, options = {})
+    options = DEFAULT_OBTAIN_ENTRIES_OPTIONS.merge(options)
     if descriptor.class_names.empty?
-      meths = @ri_reader.methods_under_matching("", /(#|\.)#{descriptor.method_name}$/, true)
-      return meths unless meths.empty?
-      return [] unless try_partial
-      # try with partial matches: foo -> foobar, foobaz    anywhere in the
-      # hierarchy
-      meths = @ri_reader.methods_under_matching("", /(#|\.)#{descriptor.method_name}/, true)
-      return meths
+      seps = separators(descriptor.is_class_method)
+      return obtain_unqualified_method_entries(descriptor.method_name, seps,
+                                               options[:lookup_order])
     end
 
     # if we're here, some namespace was given
     full_ns_name = descriptor.class_names.join("::")
     if descriptor.method_name == nil
-      ns = @ri_reader.get_class_entry(full_ns_name)
-      return [ns] if ns
-      # nested namespace
-      namespaces = @ri_reader.namespaces_under_matching("", /::#{full_ns_name}$/, true)
-      return namespaces unless namespaces.empty?
-      return [] unless try_partial
-      # partial match
-      namespaces = @ri_reader.namespaces_under_matching("", /^#{full_ns_name}/, false)
-      return namespaces unless namespaces.empty?
-      # partial and nested
-      namespaces = @ri_reader.namespaces_under_matching("", /::#{full_ns_name}[^:]*$/, true)
-      return namespaces
+      return obtain_namespace_entries(full_ns_name, options[:lookup_order])
     else  # both namespace and method
       seps = separators(descriptor.is_class_method)
-      seps.each do |sep|
-        entry = @ri_reader.get_method_entry("#{full_ns_name}#{sep}#{descriptor.method_name}")
-        return [entry] if entry
-      end
-      # no exact matches
-      sep_re = "(" + seps.map{|x| Regexp.escape(x)}.join("|") + ")"
-      # nested
-      methods = @ri_reader.methods_under_matching("", /::#{full_ns_name}#{sep_re}#{descriptor.method_name}$/, true)
-      return methods unless methods.empty?
-
-      return [] unless try_partial
-      # partial
-      methods = @ri_reader.methods_under_matching(full_ns_name, /#{sep_re}#{descriptor.method_name}/, false)
-      return methods unless methods.empty?
-      # partial and nested
-      methods = @ri_reader.methods_under_matching("", /::#{full_ns_name}#{sep_re}#{descriptor.method_name}/, true)
-      return methods
+      return obtain_qualified_method_entries(full_ns_name, descriptor.method_name, 
+                                             seps, options[:lookup_order])
     end
   end
 
@@ -160,26 +177,42 @@ class RiService
     return nil
   end
 
-  def info(keyw, type = :ansi)
+  DEFAULT_INFO_OPTIONS = {
+    :formatter => :ansi,
+    :width     => 72,
+  }
+
+  def matches(keyword, options = {})
+    options = DEFAULT_INFO_OPTIONS.merge(options)
+    return nil if keyword.strip.empty?
+    descriptor = NameDescriptor.new(keyword)
+    ret = obtain_entries(descriptor, options).map{|x| x.full_name}
+    ret ? ret : nil
+  rescue RiError
+    return nil
+  end
+
+  def info(keyw, options = {})
+    options = DEFAULT_INFO_OPTIONS.merge(options)
     return nil if keyw.strip.empty?
     descriptor = NameDescriptor.new(keyw)
-    entries = obtain_entries(descriptor, true)
+    entries = obtain_entries(descriptor, options)
 
     case entries.size
     when 0; nil
     when 1
       case entries[0].type
       when :namespace
-        capture_stdout(display(type)) do |display|
+        capture_stdout(display(options)) do |display|
           display.display_class_info(@ri_reader.get_class(entries[0]), @ri_reader)
         end
       when :method
-        capture_stdout(display(type)) do |display|
+        capture_stdout(display(options)) do |display|
           display.display_method_info(@ri_reader.get_method(entries[0]))
         end
       end
     else
-      capture_stdout(display(type)) do |display|
+      capture_stdout(display(options)) do |display|
         formatter = display.formatter
         formatter.draw_line("Multiple choices:")
         formatter.blankline
@@ -190,16 +223,17 @@ class RiService
     return nil
   end
 
-  def args(keyword, type = :ansi)
+  def args(keyword, options = {})
+    options = DEFAULT_INFO_OPTIONS.merge(options)
     return nil if keyword.strip.empty?
     descriptor = NameDescriptor.new(keyword)
-    entries = obtain_entries(descriptor, false)
+    entries = obtain_entries(descriptor, options)
     return nil if entries.empty? || RiIndex::ClassEntry === entries[0]
 
     params_text = ""
     entries.each do |entry|
       desc = @ri_reader.get_method(entry)
-      params_text << capture_stdout(display(type)) do |display|
+      params_text << capture_stdout(display(options)) do |display|
         display.full_params(desc)
       end
     end
@@ -224,6 +258,86 @@ class RiService
 
   private
 
+  def obtain_unqualified_method_entries(name, separators, order)
+    sep_re = "(" + separators.map{|x| Regexp.escape(x)}.join("|") + ")"
+    matcher = MatchFinder.new do |m|
+      m.add_matcher(:exact) do
+        m.yield @ri_reader.methods_under_matching("", /#{sep_re}#{name}$/, true)
+      end
+      m.add_matcher(:exact_ci) do
+        m.yield @ri_reader.methods_under_matching("", /#{sep_re}#{name}$/i, true)
+      end
+      m.add_matcher(:partial) do
+        m.yield @ri_reader.methods_under_matching("", /#{sep_re}#{name}/, true)
+      end
+      m.add_matcher(:partial_ci) do
+        m.yield @ri_reader.methods_under_matching("", /#{sep_re}#{name}/i, true)
+      end
+    end
+    matcher.get_matches(order)
+  end
+
+  def obtain_qualified_method_entries(namespace, method, separators, order)
+    matcher = MatchFinder.new do |m|
+      m.add_matcher(:exact) do
+        separators.each do |sep|
+          m.yield @ri_reader.get_method_entry("#{namespace}#{sep}#{method}")
+        end
+      end
+      sep_re = "(" + separators.map{|x| Regexp.escape(x)}.join("|") + ")"
+      m.add_matcher(:exact_ci) do
+        m.yield @ri_reader.methods_under_matching("", /^#{namespace}#{sep_re}#{method}$/i, true)
+      end
+      m.add_matcher(:nested) do
+        m.yield @ri_reader.methods_under_matching("", /::#{namespace}#{sep_re}#{method}$/, true)
+      end
+      m.add_matcher(:nested_ci) do
+        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)
+      end
+      m.add_matcher(:partial_ci) do
+        m.yield @ri_reader.methods_under_matching("", /^#{namespace}#{sep_re}#{method}/i, true)
+      end
+      m.add_matcher(:nested_partial) do
+        m.yield @ri_reader.methods_under_matching("", /::#{namespace}#{sep_re}#{method}/, true)
+      end
+      m.add_matcher(:nested_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)
+    matcher = MatchFinder.new do |m|
+      m.add_matcher(:exact){ m.yield @ri_reader.get_class_entry(name) }
+      m.add_matcher(:exact_ci) do 
+        m.yield @ri_reader.namespaces_under_matching("", /^#{name}$/i, true)
+      end
+      m.add_matcher(:nested) do 
+        m.yield @ri_reader.namespaces_under_matching("", /::#{name}$/, true)
+      end
+      m.add_matcher(:nested_ci) do 
+        m.yield @ri_reader.namespaces_under_matching("", /::#{name}$/i, true)
+      end
+      m.add_matcher(:partial) do
+        m.yield @ri_reader.namespaces_under_matching("", /^#{name}/, true)
+      end
+      m.add_matcher(:partial_ci) do
+        m.yield @ri_reader.namespaces_under_matching("", /^#{name}/i, true)
+      end
+      m.add_matcher(:nested_partial) do
+        m.yield @ri_reader.namespaces_under_matching("", /::#{name}[^:]*$/, true)
+      end
+      m.add_matcher(:nested_partial_ci) do
+        m.yield @ri_reader.namespaces_under_matching("", /::#{name}[^:]*$/i, true)
+      end
+    end
+    matcher.get_matches(order)
+  end
+
   def _class_list(keyword, rep)
     return nil if keyword.strip.empty?
     entries = @ri_reader.methods_under_matching("", /#{keyword}$/, true)
@@ -242,16 +356,22 @@ class RiService
     when nil;   [".","#"]
     end
   end
-  def display(type)
+
+  DEFAULT_DISPLAY_OPTIONS = {
+    :formatter => :ansi,
+    :width     => 72,
+  }
+  def display(opt = {})
+    opt = DEFAULT_DISPLAY_OPTIONS.merge(opt)
     options = Options.new
     options.use_stdout = true
-    case type.to_sym
+    case opt[:formatter].to_sym
     when :ansi
       options.formatter = RedirectedAnsiFormatter
     else
       options.formatter = RedirectedTextFormatter
     end
-    options.width = 72
+    options.width = opt[:width]
     StringRedirectedDisplay.new(options)
   end
 

data/lib/fastri/version.rb

@@ -2,7 +2,7 @@
 #
 
 module FastRI
-  FASTRI_VERSION      = "0.1.0"
+  FASTRI_VERSION      = "0.1.1"
   FASTRI_INDEX_FORMAT = "0.1.0"
 end
 # vi: set sw=2 expandtab:

data/pre-install.rb

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

data/test/test_name_descriptor.rb

@@ -0,0 +1,35 @@
+# Copyright (C) 2006  Mauricio Fernandez <mfp@acm.org>
+#
+
+require 'test/unit'
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+$:.unshift "lib"
+require 'fastri/name_descriptor'
+
+class TestNameDescriptor < Test::Unit::TestCase
+  include FastRI
+  def helper(text)
+    desc = NameDescriptor.new(text)
+    [desc.class_names, desc.method_name, desc.is_class_method]
+  end
+
+  def test_unqualified_methods
+    assert_equal([[], "foo", nil], helper("foo"))
+    assert_equal([[], "foo", false], helper("#foo"))
+    assert_equal([[], "foo", nil], helper(".foo"))
+    assert_equal([[], "foo", true], helper("::foo"))
+  end
+
+  def test_qualified_methods
+    assert_equal([["Foo"], "bar", nil], helper("foo.bar"))
+    assert_equal([["Foo"], "bar", true], helper("foo::bar"))
+    assert_equal([["Foo"], "bar", false], helper("foo#bar"))
+    assert_equal([["Foo", "Bar"], "baz", true], helper("foo::bar::baz"))
+  end
+
+  def test_namespaces
+    assert_equal([["Foo"], nil, nil], helper("Foo"))
+    assert_equal([["Foo", "Bar"], nil, nil], helper("foo::Bar"))
+    assert_equal([["Foo", "Bar", "Baz"], nil, nil], helper("Foo::Bar::Baz"))
+  end
+end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.0
 specification_version: 1
 name: fastri
 version: !ruby/object:Gem::Version 
-  version: 0.1.0.1
-date: 2006-11-08 00:00:00 +01:00
+  version: 0.1.1.1
+date: 2006-11-10 00:00:00 +01:00
 summary: RI docs across machines, faster and smarter than ri.
 require_paths: 
 - lib
@@ -60,6 +60,8 @@ files:
 - lib/fastri/ri_index.rb
 - lib/fastri/ri_service.rb
 - lib/fastri/version.rb
+- lib/fastri/name_descriptor.rb
+- CHANGES
 - COPYING
 - LEGAL
 - LICENSE
@@ -67,10 +69,13 @@ files:
 - README.en
 - test/test_ri_index.rb
 - test/test_functional_ri_service.rb
+- test/test_name_descriptor.rb
 - setup.rb
+- pre-install.rb
 test_files: 
 - test/test_ri_index.rb
 - test/test_functional_ri_service.rb
+- test/test_name_descriptor.rb
 rdoc_options: 
 - --title
 - "FastRI: better, faster ri"