fastri 0.1.0.0

data/Rakefile

@@ -0,0 +1,95 @@
+$:.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
+
+# {{{ Package tasks
+
+require 'fastri/version'
+
+PKG_REVISION = ".0"
+PKG_FILES = FileList[
+"bin/fri", "bin/fastri-server", "bin/ri-emacs",
+"lib/**/*.rb",
+"COPYING", "LEGAL", "LICENSE", "Rakefile", "README.*", "test/*.rb",
+"setup.rb", 
+]
+
+require 'rake/gempackagetask'
+Spec = Gem::Specification.new do |s|
+  s.name = "fastri"
+  s.version = FastRI::FASTRI_VERSION + PKG_REVISION
+  s.summary = "RI docs across machines, faster and smarter than ri."
+  s.description = <<EOF
+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.
+EOF
+  s.files = PKG_FILES.to_a
+  s.require_path = 'lib'
+  s.author = "Mauricio Fernandez"
+  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.has_rdoc = true
+  #s.extra_rdoc_files = %w[]
+  s.rdoc_options << "--title" << 'FastRI: better, faster ri'
+  s.test_files = Dir["test/test_*.rb"]
+  s.post_install_message = <<EOF
+
+A small note about the RubyGems + FastRI. 
+=========================================
+RubyGems adds a noticable overhead to fri, making it run slower than if you
+installed it directly from the tarball with setup.rb.
+
+Compare the execution time when installed with RubyGems:
+  $ time fri -f plain String > /dev/null
+
+  real	0m0.385s
+  user	0m0.244s
+  sys	0m0.036s
+
+to the time fri actually takes to run, without the overhead introduced by 
+RubyGems:
+  $ time ruby bin/fri -f plain String > /dev/null
+
+  real	0m0.088s
+  user	0m0.040s
+  sys	0m0.008s
+
+If you care about those extra 300ms (and there are situations where they will
+matter, e.g. when using fri for method completion), get FastRI from the
+tarballs.
+
+EOF
+end
+
+task :gem => [:test]
+Rake::GemPackageTask.new(Spec) do |p|
+  p.need_tar = true
+end
+
+# vim: set sw=2 ft=ruby:

data/bin/fastri-server

@@ -0,0 +1,188 @@
+#!/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'
+
+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 = [ RI::Paths::SYSDIR, RI::Paths::SITEDIR, RI::Paths::HOMEDIR ].find_all do |p|
+    p && File.directory?(p)
+  end
+  begin
+    require 'rubygems'
+    gemdirs = Dir["#{Gem.path}/doc/*/ri"]
+    gems = Hash.new{|h,k| h[k] = []}
+    gemdirs.each do |path|
+      gemname, version = %r{/([^/]+)-(.*)/ri$}.match(path).captures
+      if gemname.nil? # doesn't follow any conventions :(
+        gems[path[%r{/([^/]+)/ri$}, 1]] << ["unknown", path]
+      else
+        gems[gemname] << [version, path]
+      end
+    end
+    gems.sort_by{|name, _| name}.each do |name, versions|
+      version, path = versions.sort.last
+      puts "Indexing RI docs for #{name} version #{version}."
+      paths << path
+    end
+  rescue LoadError
+  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
+
+#{{{ Main program
+
+require 'optparse'
+
+options = {:allowed_hosts => ["127.0.0.1"], :addr => "127.0.0.1",
+  :index_file => File.expand_path("~/.fastri-index")}
+OptionParser.new do |opts|
+  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("-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)
+
+drb_addr = "druby://#{options[:addr]}:0"
+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
+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]}
+
+# {{{ 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,67 @@
+#!/usr/bin/env ruby
+# fri: access RI documentation through DRb
+# Copyright (C) 2006 Mauricio Fernandez <mfp@acm.org>
+#
+
+require 'rinda/ring'
+require 'optparse'
+
+# 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 => "ansi"
+}
+override_addr_env = false
+optparser = OptionParser.new do |opts|
+  opts.banner = "Usage: fri [options] <query>"
+
+  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
+
+  opts.on("-f", "--format FMT", "Format to use when displaying output:",
+          "   ansi, plain (default: ansi)") do |format|
+    options[:format] = format
+  end
+
+  opts.on("-h", "--help", "Show this help message") do 
+    puts opts
+    exit
+  end
+end
+optparser.parse!
+
+if ARGV.empty?
+  puts optparser
+  exit
+end
+
+if override_addr_env
+  addr = "druby://#{options[:addr]}:0"
+else
+  addr =  "druby://#{ENV["FASTRI_ADDR"]||options[:addr]}:0"
+end
+
+begin
+  DRb.start_service(addr)
+  ring_server = Rinda::RingFinger.primary
+rescue Exception
+  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]
+puts service.info(ARGV[0], options[:format])
+# vi: set sw=2 expandtab:

data/bin/ri-emacs

@@ -0,0 +1,188 @@
+#!/usr/bin/env ruby
+## drop-in replacement for the ri-emacs helper script for use 
+#  with ri-ruby.el, using the FastRI service via DRb
+#
+# Based on ri-emacs.rb by Kristof Bastiaensen <kristof@vleeuwen.org>
+#
+#    Copyright (C) 2004,2006 Kristof Bastiaensen
+#                  2006 Mauricio Fernandez <mfp@acm.org>
+#    
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+#----------------------------------------------------------------------
+
+require 'rinda/ring'
+require 'optparse'
+
+# {{{ cmdline parsing and service discovery
+# 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"}
+override_addr_env = false
+optparser = OptionParser.new do |opts|
+  opts.banner = "Usage: ri-emacs [options] <query>"
+
+  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
+
+  opts.on("-h", "--help", "Show this help message") do 
+    puts opts
+    exit
+  end
+end
+optparser.parse!
+
+if override_addr_env
+  addr = "druby://#{options[:addr]}:0"
+else
+  addr =  "druby://#{ENV["FASTRI_ADDR"]||options[:addr]}:0"
+end
+
+begin
+  DRb.start_service(addr)
+  ring_server = Rinda::RingFinger.primary
+rescue Exception
+  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]
+
+class EventLoop
+  def initialize(ri)
+    @ri = ri
+  end
+
+  def run
+    puts "READY"
+    loop do
+      line = $stdin.gets
+      cmd, p = /(\w+)(.*)$/.match(line)[1..2]
+      p.strip!
+      case cmd
+      when "TRY_COMPLETION";       puts complete_try(p)
+      when "COMPLETE_ALL";         puts complete_all(p)
+      when "LAMBDA";               puts complete_lambda(p)
+      when "CLASS_LIST";           puts class_list(p)
+      when "CLASS_LIST_WITH_FLAG"; puts class_list_with_flag(p)
+      when "DISPLAY_ARGS";         display_args(p)
+      when "DISPLAY_INFO";         display_info(p)
+      end
+    end
+  end
+
+  def complete_try(keyw)
+    list = @ri.completion_list(keyw)
+    if list.nil? 
+      return "nil"
+    elsif list.size == 1 and
+      list[0].split(/(::)|#|\./) == keyw.split(/(::)|#|\./)
+      return "t"
+    end
+
+    first = list.shift;
+    if first =~ /(.*)((?:::)|(?:#))(.*)/
+      other = $1 + ($2 == "::" ? "#" : "::") + $3
+    end
+
+    len = first.size
+    match_both = false
+    list.each do |w|
+      while w[0, len] != first[0, len]
+        if other and w[0, len] == other[0, len]
+          match_both = true
+          break
+        end
+        len -= 1
+      end
+    end
+
+    if match_both
+      return other.sub(/(.*)((?:::)|(?:#))/) { $1 + "." }[0, len].inspect
+    else
+      return first[0, len].inspect
+    end
+  end
+
+  def complete_all(keyw)
+    list = @ri.completion_list(keyw)
+    if list.nil?
+      "nil"
+    else
+      "(" + list.map { |w| w.inspect }.join(" ") + ")"
+    end
+  end
+
+  def complete_lambda(keyw)
+    list = @ri.completion_list(keyw)
+    if list.nil?
+      "nil"
+    else
+      if list.find { |n| n.split(/(::)|#|\./) == keyw.split(/(::)|#|\./) }
+        "t"
+      else
+        "nil"
+      end
+    end
+  end
+
+  def class_list(keyw)
+    list = @ri.class_list(keyw)
+    if list
+      "(" + list.map{|x| "(#{x.inspect})"}.join(" ") + ")"
+    else
+      "nil"
+    end
+  end
+
+  def class_list_with_flag(keyw)
+    list = @ri.class_list_with_flag(keyw)
+    if list
+      "(" + list.map{|x| "(#{x.inspect})"}.join(" ") + ")"
+    else
+      "nil"
+    end
+  end
+
+  def display_args(keyw)
+    data = @ri.args(keyw)
+    puts data if data
+    puts "RI_EMACS_END_OF_INFO"
+  end
+
+  def display_info(keyw)
+    data = @ri.info(keyw)
+    puts data if data
+    puts "RI_EMACS_END_OF_INFO"
+  end
+end
+
+
+#{{{ event loop
+$stdout.sync = true
+EventLoop.new(service).run
+
+# vi: set sw=2 expandtab: