shoesgem 0.1424.0

data/shoes/ruby/lib/find.rb

@@ -0,0 +1,81 @@
+#
+# find.rb: the Find module for processing all files under a given directory.
+#
+
+#
+# The +Find+ module supports the top-down traversal of a set of file paths.
+#
+# For example, to total the size of all files under your home directory,
+# ignoring anything in a "dot" directory (e.g. $HOME/.ssh):
+#
+#   require 'find'
+#
+#   total_size = 0
+#
+#   Find.find(ENV["HOME"]) do |path|
+#     if FileTest.directory?(path)
+#       if File.basename(path)[0] == ?.
+#         Find.prune       # Don't look any further into this directory.
+#       else
+#         next
+#       end
+#     else
+#       total_size += FileTest.size(path)
+#     end
+#   end
+#
+module Find
+
+  #
+  # Calls the associated block with the name of every file and directory listed
+  # as arguments, then recursively on their subdirectories, and so on.
+  #
+  # See the +Find+ module documentation for an example.
+  #
+  def find(*paths) # :yield: path
+    block_given? or return enum_for(__method__, *paths)
+
+    paths.collect!{|d| raise Errno::ENOENT unless File.exist?(d); d.dup}
+    while file = paths.shift
+      catch(:prune) do
+	yield file.dup.taint
+        next unless File.exist? file
+	begin
+	  if File.lstat(file).directory? then
+	    d = Dir.open(file)
+	    begin
+	      for f in d
+		next if f == "." or f == ".."
+		if File::ALT_SEPARATOR and file =~ /^(?:[\/\\]|[A-Za-z]:[\/\\]?)$/ then
+		  f = file + f
+		elsif file == "/" then
+		  f = "/" + f
+		else
+		  f = File.join(file, f)
+		end
+		paths.unshift f.untaint
+	      end
+	    ensure
+	      d.close
+	    end
+	  end
+       rescue Errno::ENOENT, Errno::EACCES
+	end
+      end
+    end
+  end
+
+  #
+  # Skips the current file or directory, restarting the loop with the next
+  # entry. If the current file is a directory, that directory will not be
+  # recursively entered. Meaningful only within the block associated with
+  # Find::find.
+  #
+  # See the +Find+ module documentation for an example.
+  #
+  def prune
+    throw :prune
+  end
+
+  module_function :find, :prune
+end

data/shoes/ruby/lib/forwardable.rb

@@ -0,0 +1,270 @@
+#
+#   forwardable.rb - 
+#   	$Release Version: 1.1$
+#   	$Revision: 24174 $
+#   	by Keiju ISHITSUKA(keiju@ishitsuka.com)
+#	original definition by delegator.rb
+#       Revised by Daniel J. Berger with suggestions from Florian Gross.
+#
+#       Documentation by James Edward Gray II and Gavin Sinclair
+#
+# == Introduction
+#
+# This library allows you delegate method calls to an object, on a method by
+# method basis.
+#
+# == Notes
+#
+# Be advised, RDoc will not detect delegated methods.
+#
+# <b>forwardable.rb provides single-method delegation via the
+# def_delegator() and def_delegators() methods.  For full-class
+# delegation via DelegateClass(), see delegate.rb.</b>
+#
+# == Examples
+#
+# === Forwardable
+#
+# Forwardable makes building a new class based on existing work, with a proper
+# interface, almost trivial.  We want to rely on what has come before obviously,
+# but with delegation we can take just the methods we need and even rename them
+# as appropriate.  In many cases this is preferable to inheritance, which gives
+# us the entire old interface, even if much of it isn't needed.
+#
+#   class Queue
+#     extend Forwardable
+#     
+#     def initialize
+#       @q = [ ]    # prepare delegate object
+#     end
+#     
+#     # setup preferred interface, enq() and deq()...
+#     def_delegator :@q, :push, :enq
+#     def_delegator :@q, :shift, :deq
+#     
+#     # support some general Array methods that fit Queues well
+#     def_delegators :@q, :clear, :first, :push, :shift, :size
+#   end
+# 
+#   q = Queue.new
+#   q.enq 1, 2, 3, 4, 5
+#   q.push 6
+# 
+#   q.shift    # => 1
+#   while q.size > 0
+#     puts q.deq
+#   end
+# 
+#   q.enq "Ruby", "Perl", "Python"
+#   puts q.first
+#   q.clear
+#   puts q.first
+#
+# <i>Prints:</i>
+#
+#   2
+#   3
+#   4
+#   5
+#   6
+#   Ruby
+#   nil
+#
+# SingleForwardable can be used to setup delegation at the object level as well.
+#
+#    printer = String.new
+#    printer.extend SingleForwardable        # prepare object for delegation
+#    printer.def_delegator "STDOUT", "puts"  # add delegation for STDOUT.puts()
+#    printer.puts "Howdy!"
+#
+# Also, SingleForwardable can be use to Class or Module.
+#
+#    module Facade
+#      extend SingleForwardable
+#      def_delegator :Implementation, :service
+#
+#      class Implementation
+#	  def service...
+#      end
+#    end
+#
+# If you want to use both Forwardable and SingleForwardable, you can
+# use methods def_instance_delegator and def_single_delegator, etc.
+# 
+# If the object isn't a Module and Class, You can too extend
+# Forwardable module. 
+#    printer = String.new
+#    printer.extend Forwardable              # prepare object for delegation
+#    printer.def_delegator "STDOUT", "puts"  # add delegation for STDOUT.puts()
+#    printer.puts "Howdy!"
+#
+# <i>Prints:</i>
+#
+#    Howdy!
+
+#
+# The Forwardable module provides delegation of specified
+# methods to a designated object, using the methods #def_delegator
+# and #def_delegators.
+#
+# For example, say you have a class RecordCollection which
+# contains an array <tt>@records</tt>.  You could provide the lookup method
+# #record_number(), which simply calls #[] on the <tt>@records</tt>
+# array, like this:
+#
+#   class RecordCollection
+#     extend Forwardable
+#     def_delegator :@records, :[], :record_number
+#   end
+#
+# Further, if you wish to provide the methods #size, #<<, and #map,
+# all of which delegate to @records, this is how you can do it:
+#
+#   class RecordCollection
+#     # extend Forwardable, but we did that above
+#     def_delegators :@records, :size, :<<, :map
+#   end
+#   f = Foo.new
+#   f.printf ...
+#   f.gets
+#   f.content_at(1)
+#
+# Also see the example at forwardable.rb.
+
+module Forwardable
+  FORWARDABLE_VERSION = "1.1.0"
+
+  @debug = nil
+  class<<self
+    attr_accessor :debug
+  end
+
+  # Takes a hash as its argument.  The key is a symbol or an array of
+  # symbols.  These symbols correspond to method names.  The value is
+  # the accessor to which the methods will be delegated.
+  #
+  # :call-seq:
+  #    delegate method => accessor
+  #    delegate [method, method, ...] => accessor
+  #
+  def instance_delegate(hash)
+    hash.each{ |methods, accessor|
+      methods = methods.to_s unless methods.respond_to?(:each)
+      methods.each{ |method|
+        def_instance_delegator(accessor, method)
+      }
+    }
+  end
+
+  #
+  # Shortcut for defining multiple delegator methods, but with no
+  # provision for using a different name.  The following two code
+  # samples have the same effect:
+  #
+  #   def_delegators :@records, :size, :<<, :map
+  #
+  #   def_delegator :@records, :size
+  #   def_delegator :@records, :<<
+  #   def_delegator :@records, :map
+  #
+  def def_instance_delegators(accessor, *methods)
+    methods.delete("__send__")
+    methods.delete("__id__")
+    for method in methods
+      def_instance_delegator(accessor, method)
+    end
+  end
+
+  def def_instance_delegator(accessor, method, ali = method)
+    line_no = __LINE__; str = %{
+      def #{ali}(*args, &block)
+	begin
+	  #{accessor}.__send__(:#{method}, *args, &block)
+	rescue Exception
+	  $@.delete_if{|s| %r"#{Regexp.quote(__FILE__)}"o =~ s} unless Forwardable::debug
+	  ::Kernel::raise
+	end
+      end
+    }
+    # If it's not a class or module, it's an instance
+    begin
+      module_eval(str, __FILE__, line_no)
+    rescue
+      instance_eval(str, __FILE__, line_no)
+    end
+
+  end
+
+  alias delegate instance_delegate
+  alias def_delegators def_instance_delegators
+  alias def_delegator def_instance_delegator
+end
+
+#
+# Usage of The SingleForwardable is like Fowadable module.
+#
+module SingleForwardable
+  # Takes a hash as its argument.  The key is a symbol or an array of
+  # symbols.  These symbols correspond to method names.  The value is
+  # the accessor to which the methods will be delegated.
+  #
+  # :call-seq:
+  #    delegate method => accessor
+  #    delegate [method, method, ...] => accessor
+  #
+  def single_delegate(hash)
+    hash.each{ |methods, accessor|
+      methods = methods.to_s unless methods.respond_to?(:each)
+      methods.each{ |method|
+        def_single_delegator(accessor, method)
+      }
+    }
+  end
+
+  #
+  # Shortcut for defining multiple delegator methods, but with no
+  # provision for using a different name.  The following two code
+  # samples have the same effect:
+  #
+  #   def_delegators :@records, :size, :<<, :map
+  #
+  #   def_delegator :@records, :size
+  #   def_delegator :@records, :<<
+  #   def_delegator :@records, :map
+  #
+  def def_single_delegators(accessor, *methods)
+    methods.delete("__send__")
+    methods.delete("__id__")
+    for method in methods
+      def_single_delegator(accessor, method)
+    end
+  end
+
+  #
+  # Defines a method _method_ which delegates to _obj_ (i.e. it calls
+  # the method of the same name in _obj_).  If _new_name_ is
+  # provided, it is used as the name for the delegate method.
+  #
+  def def_single_delegator(accessor, method, ali = method)
+    line_no = __LINE__; str = %{
+      def #{ali}(*args, &block)
+	begin
+	  #{accessor}.__send__(:#{method}, *args, &block)
+	rescue Exception
+	  $@.delete_if{|s| %r"#{Regexp.quote(__FILE__)}"o =~ s} unless Forwardable::debug
+	  ::Kernel::raise
+	end
+      end
+    }
+
+    instance_eval(str, __FILE__, __LINE__)
+  end
+
+  alias delegate single_delegate
+  alias def_delegators def_single_delegators
+  alias def_delegator def_single_delegator
+end
+
+
+
+

data/shoes/ruby/lib/ftsearch/analysis/analyzer.rb

@@ -0,0 +1,16 @@
+# Copyright (C) 2006  Mauricio Fernandez <mfp@acm.org>
+#
+
+module FTSearch
+module Analysis
+
+class Analyzer
+  def find_suffixes(text)
+    ret = []
+    append_suffixes(ret, text, 0)
+    ret
+  end
+end
+
+end # Analysis
+end # FTSearch

data/shoes/ruby/lib/ftsearch/analysis/simple_identifier_analyzer.rb

@@ -0,0 +1,23 @@
+
+# Copyright (C) 2006  Mauricio Fernandez <mfp@acm.org>
+#
+
+require 'strscan'
+require 'ftsearch/analysis/analyzer'
+
+module FTSearch
+module Analysis
+
+class SimpleIdentifierAnalyzer < Analyzer
+  def append_suffixes(array, text, offset)
+    sc = StringScanner.new(text)
+    sc.skip(/[^A-Za-z_]+/)
+    until sc.eos?
+      array << (sc.pos + offset)
+      break unless sc.skip(/[A-Za-z_][A-Za-z0-9_]*[^A-Za-z_]*/)
+    end
+  end
+end
+
+end #  Analyzer
+end  # FTSearch

data/shoes/ruby/lib/ftsearch/analysis/whitespace_analyzer.rb

@@ -0,0 +1,22 @@
+# Copyright (C) 2006  Mauricio Fernandez <mfp@acm.org>
+#
+
+require 'strscan'
+require 'ftsearch/analysis/analyzer'
+
+module FTSearch
+module Analysis
+  class WhiteSpaceAnalyzer < Analyzer
+    def append_suffixes(array, text, offset)
+      sc = StringScanner.new(text)
+      sc.skip(/(\s|\n)*/)
+      until sc.eos?
+        array << (sc.pos + offset)
+        break unless sc.skip(/\S+\s*/)
+      end
+
+      array
+    end
+  end
+end #  Analyzer
+end  # FTSearch

data/shoes/ruby/lib/ftsearch/document_map_reader.rb

@@ -0,0 +1,106 @@
+# Copyright (C) 2006  Mauricio Fernandez <mfp@acm.org>
+#
+
+module FTSearch
+
+class DocumentMapReader
+  DEFAULT_OPTIONS = {
+    :path => nil,
+    :io   => nil,
+  }
+  def initialize(options = {})
+    options = DEFAULT_OPTIONS.merge(options)
+    unless options[:path] || options[:io]
+      raise ArgumentError, "Need either the path to the suffix array file or an IO."
+    end
+    if options[:path]
+      io = File.open(options[:path], "rb")
+    else
+      io = options[:io]
+    end
+    @uri_tbl, @field_arr = Marshal.load(io)
+  end
+
+  def document_id(suffix_idx, offset)
+    idx = binary_search(@field_arr, offset, 0, @field_arr.size)
+    @field_arr[idx][1]
+  end
+
+  def field_id(suffix_idx, offset)
+    idx = binary_search(@field_arr, offset, 0, @field_arr.size)
+    @field_arr[idx][2]
+  end
+
+  def field_size(suffix_idx, offset)
+    idx = binary_search(@field_arr, offset, 0, @field_arr.size)
+    @field_arr[idx][3]
+  end
+
+  def field_info(suffix_idx, offset)
+    idx = binary_search(@field_arr, offset, 0, @field_arr.size)
+    @field_arr[idx]
+  end
+
+  def document_uri(suffix_idx, offset)
+    doc_id = document_id(suffix_idx, offset)
+    @uri_tbl[doc_id]
+  end
+
+  def document_id_to_uri(doc_id)
+    @uri_tbl[doc_id]
+  end
+
+  def offsets_to_field_infos(offsets)
+    offsets.map{|off| @field_arr[binary_search(@field_arr, off, 0, @field_arr.size)]}
+  end
+
+  def rank_offsets(offsets, weights)
+    h = Hash.new{|h,k| h[k] = 0.0}
+    offsets_to_field_infos(offsets).each do |offset, doc_id, field_id, field_size|
+      h[doc_id] += weights[field_id] / field_size
+    end
+    sort_score_hash(h)
+  end
+
+  def rank_offsets_probabilistic(offsets, weights, iterations)
+    h     = Hash.new{|h,k| h[k] = 0.0}
+    infos = offsets_to_field_infos(offsets)
+    max   = infos.size
+    while iterations > 0
+      offset, doc_id, field_id, field_size = infos[rand(max)]
+      h[doc_id] += weights[field_id] / field_size
+      iterations -= 1
+    end
+    sort_score_hash(h)
+  end
+
+  def dump_data
+    [@uri_tbl, @field_arr]
+  end
+
+  def num_documents
+    @uri_tbl.size
+  end
+
+  private
+  def sort_score_hash(h)
+    h.sort_by{|_,score| -score}
+  end
+
+  def binary_search(arr, offset, from, to)
+    middle = 0
+    while to - from > 1
+      middle = (from + to) / 2
+      pivot,  = arr[middle]
+      if offset < pivot
+        to = middle
+      else
+        from = middle
+      end
+    end
+
+    from
+  end
+
+end
+end  # FTSearch

data/shoes/ruby/lib/ftsearch/document_map_writer.rb

@@ -0,0 +1,46 @@
+# Copyright (C) 2006  Mauricio Fernandez <mfp@acm.org>
+#
+
+require 'ftsearch/util'
+
+module FTSearch
+class DocumentMapWriter
+  include InMemoryWriter
+
+  DEFAULT_OPTIONS = {
+    :path => "docmap-#{Process.pid}-#{rand(100000)}",
+  }
+  def initialize(options = {})
+    options    = DEFAULT_OPTIONS.merge(options)
+    @path      = options[:path]
+    @field_arr = []
+    @uri_tbl   = []
+    @data      = [@uri_tbl, @field_arr]
+    initialize_in_memory_buffer
+  end
+
+  def merge(doc_map_reader)
+    # TODO: general merge?
+    @uri_tbl, @field_arr = doc_map_reader.dump_data
+    @data = [@uri_tbl, @field_arr]
+  end
+
+  def add_document(doc_id, uri)
+    @uri_tbl[doc_id] = uri
+  end
+
+  def add_field(offset, doc_id, field_id, size)
+    @field_arr << [offset, doc_id, field_id, size]
+  end
+
+  def finish!
+    if @path
+      File.open(@path, "wb") do |f|
+        Marshal.dump(@data, f)
+      end
+    else
+      Marshal.dump(@data, @memory_io)
+    end
+  end
+end
+end  # FTSearch

data/shoes/ruby/lib/ftsearch/field_infos.rb

@@ -0,0 +1,46 @@
+# Copyright (C) 2006  Mauricio Fernandez <mfp@acm.org>
+#
+
+require 'ftsearch/analysis/whitespace_analyzer'
+
+module FTSearch
+class FieldInfos
+  DEFAULT_OPTIONS = {
+    :default_analyzer => FTSearch::Analysis::WhiteSpaceAnalyzer.new,
+    :stored => true,
+  }
+  def initialize(options = {})
+    options = DEFAULT_OPTIONS.merge(options)
+    @fields = {}
+    @default_options = options
+  end
+
+  def add_field(options = {})
+    options = @default_options.merge(options)
+    raise "Need a name" unless options[:name]
+    store_field_info(options)
+  end
+
+  def [](field_name)
+    if field_info = @fields[field_name]
+      field_info
+    else
+      store_field_info(:name => field_name)
+    end
+  end
+
+  private
+  def store_field_info(options)
+    options = @default_options.merge(options)
+    unless options[:analyzer]
+      if klass = options[:analyzer_class]
+        options[:analyzer] = klass.new
+      else
+        options[:analyzer] = @default_options[:default_analyzer]
+      end
+    end
+    @fields[options[:name]] = options
+  end
+end
+end  # FTSearch
+