xspond-xapian-ruby 0.1

data/ext/xapian_wrap.h

@@ -0,0 +1,65 @@
+/* ----------------------------------------------------------------------------
+ * This file was automatically generated by SWIG (http://www.swig.org).
+ * Version 1.3.32
+ * 
+ * This file is not intended to be easily readable and contains a number of 
+ * coding conventions designed to improve portability and efficiency. Do not make
+ * changes to this file unless you know what you are doing--modify the SWIG 
+ * interface file instead. 
+ * ----------------------------------------------------------------------------- */
+
+#ifndef SWIG_Xapian_WRAP_H_
+#define SWIG_Xapian_WRAP_H_
+
+namespace Swig {
+  class Director;
+}
+
+
+class SwigDirector_MatchDecider : public Xapian::MatchDecider, public Swig::Director {
+
+public:
+    SwigDirector_MatchDecider(VALUE self);
+    virtual bool operator ()(Xapian::Document const &doc) const;
+    virtual ~SwigDirector_MatchDecider();
+};
+
+
+class SwigDirector_ExpandDecider : public Xapian::ExpandDecider, public Swig::Director {
+
+public:
+    SwigDirector_ExpandDecider(VALUE self);
+    virtual bool operator ()(std::string const &term) const;
+    virtual ~SwigDirector_ExpandDecider();
+};
+
+
+class SwigDirector_Stopper : public Xapian::Stopper, public Swig::Director {
+
+public:
+    SwigDirector_Stopper(VALUE self);
+    virtual bool operator ()(std::string const &term) const;
+    virtual ~SwigDirector_Stopper();
+    virtual std::string get_description() const;
+};
+
+
+struct SwigDirector_ValueRangeProcessor : public Xapian::ValueRangeProcessor, public Swig::Director {
+
+public:
+    SwigDirector_ValueRangeProcessor(VALUE self);
+    virtual ~SwigDirector_ValueRangeProcessor();
+    virtual Xapian::valueno operator ()(std::string &begin, std::string &end);
+};
+
+
+class SwigDirector_Sorter : public Xapian::Sorter, public Swig::Director {
+
+public:
+    SwigDirector_Sorter(VALUE self);
+    virtual std::string operator ()(Xapian::Document const &doc) const;
+    virtual ~SwigDirector_Sorter();
+};
+
+
+#endif

data/lib/xapian.rb

@@ -0,0 +1,264 @@
+# :title:Ruby Xapian bindings
+# =Ruby Xapian bindings
+#
+# Original version by Paul Legato (plegato@nks.net), 4/20/06.
+#
+# Copyright (C) 2006 Networked Knowledge Systems, Inc.
+#
+# 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
+# USA
+#
+# ==Underscore methods
+# Note: Methods whose names start with an underscore character _ are internal
+# methods from the C++ API. Their functionality is not accessible in a
+# Ruby-friendly way, so this file provides wrapper code to make it easier to
+# use them from a Ruby programming idiom.  Most are also dangerous insofar as
+# misusing them can cause your program to segfault.  In particular, all of
+# Xapian's *Iterator classes are wrapped into nice Ruby-friendly Arrays.
+#
+# It should never be necessary to use any method whose name starts with an
+# underscore from user-level code. Make sure you are _VERY_ certain that you
+# know exactly what you're doing if you do use one of these methods. Beware.
+# You've been warned...
+#
+
+
+module Xapian
+  ######## load the SWIG-generated library
+  require '_xapian'
+
+
+  # iterate over two dangerous iterators (i.e. those that can cause segfaults
+  # if used improperly.)
+  # Return the results as an Array.
+  # Users should never need to use this method.
+  #
+  # Takes a block that returns some appropriate Ruby object to wrap the
+  # underlying Iterator
+  def _safelyIterate(dangerousStart, dangerousEnd) #:nodoc:
+    retval = Array.new
+    
+    item = dangerousStart
+    lastTerm = dangerousEnd
+    
+    return retval if dangerousStart.equals(dangerousEnd)
+
+    begin      
+      retval.push(yield(item))
+      item.next()
+    end while not item.equals(lastTerm) # must use primitive C++ comparator 
+    
+    return retval
+  end # _safelyIterate
+  module_function :_safelyIterate
+
+  #--
+  ### safe Ruby wrapper for the dangerous C++ Xapian::TermIterator class
+  class Xapian::Term
+    attr_accessor :term, :wdf, :termfreq
+
+    def initialize(term, wdf=nil, termfreq=nil)
+      @term = term
+      @wdf = wdf
+      @termfreq = termfreq
+    end
+
+    def ==(other)
+      return other.is_a?(Xapian::Term) && other.term == @term && other.wdf == @wdf && other.termfreq == @termfreq
+    end
+  end # class Term
+
+  ### Ruby wrapper for a Match, i.e. a Xapian::MSetIterator (Match Set) in C++.
+  # it's no longer an iterator in the Ruby version, but we want to preserve its
+  # non-iterative data.
+  # (MSetIterator is not dangerous, but it is inconvenient to use from a Ruby
+  # idiom, so we wrap it..)
+  class Xapian::Match     
+    attr_accessor :docid, :document, :rank, :weight, :collapse_count, :percent
+
+    def initialize(docid, document, rank, weight, collapse_count, percent)
+      @docid = docid
+      @document = document
+      @rank = rank
+      @weight = weight
+      @collapse_count = collapse_count
+      @percent = percent
+    end # initialize
+
+    def ==(other)
+      return other.is_a?(Xapian::Match) && other.docid == @docid && other.rank == @rank && 
+        other.weight == @weight && other.collapse_count == @collapse_count && other.percent == @percent
+    end
+
+  end # class Xapian::Match
+
+  # Ruby wrapper for an ExpandTerm, i.e. a Xapian::ESetIterator in C++
+  # Not dangerous, but inconvenient to use from a Ruby programming idiom, so we
+  # wrap it.
+  class Xapian::ExpandTerm
+    attr_accessor :name, :weight
+
+    def initialize(name, weight)
+      @name = name
+      @weight = weight
+    end # initialize
+
+    def ==(other)
+      return other.is_a?(Xapian::ExpandTerm) && other.name == @name && other.weight == @weight
+    end
+
+  end # Xapian::ExpandTerm
+
+  # Ruby wrapper for Xapian::ValueIterator
+  class Xapian::Value
+    attr_accessor :value, :valueno
+    
+    def initialize(value, valueno)
+      @value = value
+      @valueno = valueno
+    end # initialize
+
+    def ==(other)
+      return other.is_a?(Xapian::Value) && other.value == @value && other.valueno == @valueno
+    end
+  end # Xapian::Value
+
+  #--
+  # Extend Xapian::Document with a nice wrapper for its nasty input_iterators
+  class Xapian::Document
+    def terms
+      Xapian._safelyIterate(self._dangerous_termlist_begin(), self._dangerous_termlist_end()) { |item|
+        Xapian::Term.new(item.term, item.wdf)
+      }
+    end # terms
+
+    def values
+      Xapian._safelyIterate(self._dangerous_values_begin(), self._dangerous_values_end()) { |item|
+        Xapian::Value.new(item.value, item.valueno)
+      }
+    end # terms
+
+  end # class Xapian::Document
+
+  #--
+  # Extend Xapian::Query with a nice wrapper for its dangerous iterators
+  class Xapian::Query
+    def terms
+      Xapian._safelyIterate(self._dangerous_terms_begin(), self._dangerous_terms_end()) { |item|
+        Xapian::Term.new(item.term, item.wdf)
+        # termfreq is not supported by TermIterators from Queries
+      }
+    end
+  end # Xapian::Query
+
+  #--
+  # Extend Xapian::Enquire with a nice wrapper for its dangerous iterators
+  class Xapian::Enquire
+    # Get matching terms for some document.
+    # document can be either a Xapian::DocID or a Xapian::MSetIterator
+    def matching_terms(document)
+      Xapian._safelyIterate(self._dangerous_matching_terms_begin(document), 
+                            self._dangerous_matching_terms_end(document)) { |item|
+        Xapian::Term.new(item.term, item.wdf)
+      }
+    end
+  end # Xapian::Enquire
+
+  # MSetIterators are not dangerous, just inconvenient to use within a Ruby
+  # programming idiom. So we wrap them.
+  class Xapian::MSet
+    def matches
+      Xapian._safelyIterate(self._begin(), 
+                            self._end()) { |item|
+        Xapian::Match.new(item.docid, item.document, item.rank, item.weight, item.collapse_count, item.percent)
+      }
+
+    end # matches
+  end # Xapian::MSet
+
+  # ESetIterators are not dangerous, just inconvenient to use within a Ruby
+  # programming idiom. So we wrap them.
+  class Xapian::ESet
+    def terms
+      Xapian._safelyIterate(self._begin(), 
+                            self._end()) { |item|
+	# note: in the ExpandTerm wrapper, we implicitly rename
+	# ESetIterator#termname() (defined in xapian.i) to ExpandTerm#term()
+        Xapian::ExpandTerm.new(item.termname, item.weight)
+      }
+
+    end # terms
+  end # Xapian::ESet
+
+
+  #--
+  # Wrapper for the C++ class Xapian::PostingIterator
+  class Xapian::Posting
+    attr_accessor :docid, :doclength, :wdf
+
+    def initialize(docid, doclength, wdf)
+      @docid = docid
+      @doclength = doclength
+      @wdf = wdf
+    end
+
+    def ==(other)
+      return other.is_a?(Xapian::Posting) && other.docid == @docid && other.doclength == @doclength &&
+        other.wdf == @wdf
+    end
+  end # Xapian::Posting
+
+  #--
+  # Wrap some dangerous iterators..
+  class Xapian::Database
+    # Returns an Array of all Xapian::Terms for this database.
+    def allterms
+      Xapian._safelyIterate(self._dangerous_allterms_begin(), 
+                            self._dangerous_allterms_end()) { |item|
+        Xapian::Term.new(item.term, 0, item.termfreq)
+      }
+    end # allterms
+
+    # Returns an Array of Xapian::Postings for the given term.
+    # term is a string.
+    def postlist(term)
+      Xapian._safelyIterate(self._dangerous_postlist_begin(term), 
+                            self._dangerous_postlist_end(term)) { |item|
+        Xapian::Posting.new(item.docid, item.doclength, item.wdf)
+      }      
+    end # postlist(term)
+
+    # Returns an Array of Terms for the given docid.
+    def termlist(docid)
+      Xapian._safelyIterate(self._dangerous_termlist_begin(docid),
+                            self._dangerous_termlist_end(docid)) { |item|
+        Xapian::Term.new(item.term, item.wdf, item.termfreq)
+      }
+    end # termlist(docid)
+    
+
+    # Returns an Array of Xapian::Termpos objects for the given term (a String)
+    # in the given docid.
+    def positionlist(docid, term)
+      Xapian._safelyIterate(self._dangerous_positionlist_begin(docid, term),
+                            self._dangerous_positionlist_end(docid, term)) { |item|
+        item.termpos
+      }
+    end # positionlist
+
+  end # Xapian::Database
+
+
+end # Xapian module

data/tests/smoketest.rb

@@ -0,0 +1,204 @@
+#!/usr/bin/ruby -w
+#
+# smoketest.rb - test Xapian bindings for Ruby
+# Original version by Paul Legato (plegato@nks.net), 4/17/2006
+#
+# Originally based on smoketest.php from the PHP4 bindings.
+#
+# Copyright (C) 2006 Networked Knowledge Systems, Inc.
+# Copyright (C) 2008 Olly Betts
+#
+# 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., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301
+# USA
+
+require 'test/unit'
+require 'lib/xapian'
+
+class TestMatchDecider < Xapian::MatchDecider
+  def __call__(doc)
+    return doc.value(0) == "yes"
+  end
+end
+
+class XapianSmoketest < Test::Unit::TestCase
+
+  def setup 
+    @stem = Xapian::Stem.new("english")
+
+    @doc = Xapian::Document.new()
+    @doc.data = "is there anybody out there?"
+    @doc.add_posting(@stem.call("is"), 1)
+    @doc.add_posting(@stem.call("there"), 2)
+    @doc.add_posting(@stem.call("anybody"), 3)
+    @doc.add_posting(@stem.call("out"), 4)
+    @doc.add_posting(@stem.call("there"), 5)    
+    @doc.add_term("XYzzy")
+
+    @db = Xapian::inmemory_open()
+    @db.add_document(@doc)
+
+    @enq = Xapian::Enquire.new(@db)
+  end # setup
+
+  def test_version
+    # Test the version number reporting functions give plausible results.
+    @v = sprintf("%d.%d.%d", Xapian::major_version(), Xapian::minor_version(),
+                 Xapian::revision())
+    @v2 = Xapian::version_string()
+    assert_equal(@v2, @v)
+  end # test_version
+
+  def test_stem
+    assert_equal("Xapian::Stem(english)", @stem.description())    
+
+    assert_equal("is", @stem.call("is"))
+    assert_equal("go", @stem.call("going"))
+    assert_equal("want", @stem.call("wanted"))
+    assert_equal("refer", @stem.call("reference"))
+  end # test_stem
+
+  # subtests are those on which some test_foo() method depends.
+  def test_000_document
+    assert_not_nil(@doc)
+
+    assert_equal("is there anybody out there?", @doc.data())
+
+    assert_equal(@doc.termlist_count(), 5)
+    assert_equal("XYzzy", @doc.terms().first.term)
+
+    @doc.add_term("foo")
+    assert_equal(6, @doc.termlist_count())
+    assert_equal(@doc.terms.size(), @doc.termlist_count())
+
+  end # test_document
+
+  def test_001_database
+    assert_not_nil(@db)
+    assert_equal("WritableDatabase()", @db.description())
+    assert_equal(1, @db.doccount())
+  end # test_database
+
+  def test_002_queries
+    assert_equal("Xapian::Query((smoke OR test OR terms))",  
+                 Xapian::Query.new(Xapian::Query::OP_OR ,["smoke", "test", "terms"]).description())
+
+    phraseQuery = Xapian::Query.new(Xapian::Query::OP_PHRASE ,["smoke", "test", "tuple"])
+    xorQuery = Xapian::Query.new(Xapian::Query::OP_XOR, [ Xapian::Query.new("smoke"), phraseQuery, "string" ])
+
+    assert_equal("Xapian::Query((smoke PHRASE 3 test PHRASE 3 tuple))", phraseQuery.description())
+    assert_equal("Xapian::Query((smoke XOR (smoke PHRASE 3 test PHRASE 3 tuple) XOR string))", xorQuery.description())
+
+    assert_equal([Xapian::Term.new("smoke", 1), 
+                  Xapian::Term.new("string", 1), 
+                  Xapian::Term.new("test", 1), 
+                  Xapian::Term.new("tuple", 1)], xorQuery.terms())
+
+    assert_equal(Xapian::Query::OP_ELITE_SET, 10)
+  end # test_queries
+
+  def test_003_enquire
+    @enq = Xapian::Enquire.new(@db)
+    assert_not_nil(@enq)
+    
+    @enq.query = Xapian::Query.new(Xapian::Query::OP_OR, "there", "is")
+    mset = @enq.mset(0, 10)
+
+    assert_equal(1, mset.size())
+
+    # Feature test for Enquire.matching_terms()
+    assert_equal(2, @enq.matching_terms(mset.hit(0)).size())
+    assert_equal([Xapian::Term.new("is", 1), Xapian::Term.new("there", 1)],
+                 @enq.matching_terms(mset.hit(0)))
+  end # test_enquire
+
+  def test_004_mset_iterator
+    @enq = Xapian::Enquire.new(@db)
+    assert_not_nil(@enq)
+    
+    @enq.query = Xapian::Query.new(Xapian::Query::OP_OR, "there", "is")
+    mset = @enq.mset(0, 10)
+
+    assert_equal(mset.matches().size(), mset.size())
+  end
+
+
+  def test_005_eset_iterator
+    rset = Xapian::RSet.new
+
+    rset.add_document(1)
+
+    @enq = Xapian::Enquire.new(@db)
+    @enq.query = Xapian::Query.new(Xapian::Query::OP_OR, "there", "is")
+
+    eset = @enq.eset(10, rset)
+    assert_not_nil(eset)
+
+    assert_equal(3, eset.terms.size())
+  end # test_eset_iter
+
+  # Feature test for Database.allterms
+  def test_006_database_allterms
+    assert_equal(5, @db.allterms.size())
+  end
+  
+  # Feature test for Database.postlist
+  def test_007_database_postlist
+    assert_equal(1, @db.postlist("there").size())
+  end
+
+  # Feature test for Database.termlist
+  def test_008_database_termlist
+    assert_equal(5, @db.termlist(1).size())
+  end
+
+  # Feature test for Database.positionlist
+  def test_009_database_positionlist
+    assert_equal(2, @db.positionlist(1, "there").size())
+  end
+
+  # Feature test for Document.values
+  def test_010_document_values
+    assert_equal(0, @doc.values().size())
+  end
+
+  def test_011_matchdecider
+    @doc = Xapian::Document.new()
+    @doc.data = "Two"
+    @doc.add_posting(@stem.call("out"), 1)
+    @doc.add_posting(@stem.call("source"), 2)
+    @doc.add_value(0, "yes")
+    @db.add_document(@doc)
+
+    @query = Xapian::Query.new(@stem.call("out"))
+    enquire = Xapian::Enquire.new(@db)
+    enquire.query = @query
+    mset = enquire.mset(0, 10, nil, TestMatchDecider.new)
+    assert_equal(mset.size(), 1)
+    assert_equal(mset.docid(0), 2)
+  end
+
+  def test_012_metadata
+    assert_equal(@db.get_metadata('Foo'), '')
+    @db.set_metadata('Foo', 'Foo')
+    assert_equal(@db.get_metadata('Foo'), 'Foo')
+  end
+
+  def test_013_scaleweight
+    query = Xapian::Query.new("foo")
+    query2 = Xapian::Query.new(Xapian::Query::OP_SCALE_WEIGHT, query, 5);
+    assert_equal(query2.description(), "Xapian::Query(5 * foo)")
+  end
+
+end # class XapianSmoketest