xapian 1.2.18.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7acb91c45544cbc3a54f65370ec29930ee81a56d
+  data.tar.gz: d9697fe51e58d3df43368b4a38abcd73842609fb
+SHA512:
+  metadata.gz: 0e28d01dc98983d5968b336b01d1b28078dfbb5d42279fc08d797d16a3cff1d0478b8176f9fd54a9f38819287755d5ca923d47fe37bc4c57c3fdff99bcea8864
+  data.tar.gz: 648a35da910f7e9be2037f95e596cf628eba24d33a7feb32626bdbb6bbbd903cdfd04d62b81a1ecad7c2155091b8f72579f72dcc66458c6a5ab5fd9face29ba9

data/extconf.rb

@@ -0,0 +1,6 @@
+require "mkmf"
+
+dir_config('xapian')
+$libs = append_library($libs, with_config('xapianlib', 'xapian'))
+
+create_makefile('_xapian')

data/util.i

@@ -0,0 +1,220 @@
+%{
+/* ruby/util.i: custom Ruby typemaps for xapian-bindings
+ *
+ * Original version by Paul Legato (plegato@nks.net), 4/17/06.
+ * Based on the php4 and python util.i files.
+ *
+ * Copyright (C) 2006 Networked Knowledge Systems, Inc.
+ * Copyright (C) 2006,2007,2008,2009,2010 Olly Betts
+ * Copyright (C) 2010 Richard Boulton
+ *
+ * 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
+ *
+ */
+
+%}
+
+// Use SWIG directors for Ruby wrappers.
+#define XAPIAN_SWIG_DIRECTORS
+
+// We don't use the Iterator and ConstIterator wrappers which SWIG now offers,
+// so disable them to reduce the generated C++ wrapper code.
+#define SWIG_NO_EXPORT_ITERATOR_METHODS
+
+/////////////////////////////////////
+// Rename function and method names to match Ruby conventions
+// e.g. from get_data to data and from set_data to data=
+
+// Getters
+%rename("available_languages") get_available_languages;
+%rename("avlength") get_avlength;
+%rename("collapse_count") get_collapse_count;
+%rename("collection_freq") get_collection_freq;
+%rename("context") get_context;
+%rename("data") get_data;
+%rename("default_op") get_default_op;
+%rename("description") get_description;
+%rename("docid") get_docid;
+%rename("document_id") get_document_id;
+%rename("document_percentage") get_document_percentage;
+%rename("doccount") get_doccount;
+%rename("doclength") get_doclength;
+%rename("document") get_document;
+%rename("ebound") get_ebound;
+%rename("eset") get_eset;
+%rename("firstitem") get_firstitem;
+%rename("hit") get_hit;
+%rename("lastdocid") get_lastdocid;
+%rename("length") get_length;
+%rename("matches_estimated") get_matches_estimated;
+%rename("matches_lower_bound") get_matches_lower_bound;
+%rename("matches_upper_bound") get_matches_upper_bound;
+%rename("matching_terms") get_matching_terms;
+%rename("max_attained") get_max_attained;
+%rename("max_possible") get_max_possible;
+%rename("maxextra") get_maxextra;
+%rename("maxpart") get_maxpart;
+%rename("mset") get_mset;
+%rename("msg") get_msg;
+%rename("op_name") get_op_name;
+%rename("percent") get_percent;
+%rename("query") get_query;
+%rename("rank") get_rank;
+%rename("sumextra") get_sumextra;
+%rename("sumpart") get_sumpart;
+%rename("termfreq") get_termfreq;
+%rename("terms") get_terms;
+%rename("term") get_term;
+%rename("termpos") get_termpos;
+%rename("termweight") get_termweight;
+%rename("type") get_type;
+%rename("value") get_value;
+%rename("valueno") get_valueno;
+%rename("wdf") get_wdf;
+%rename("weight") get_weight;
+
+// These are 'dangerous' methods; i.e. they can cause a segfault if used
+// improperly.  We prefix with _dangerous_ so that Ruby users will not use them
+// inadvertently.
+//
+// There is a safe wrapper for their functionality provided in xapian.rb.
+
+// in Xapian::Document and Xapian::Database
+%rename("_dangerous_termlist_begin") termlist_begin;
+%rename("_dangerous_termlist_end") termlist_end;
+// in Xapian::Query
+%rename("_dangerous_terms_begin") get_terms_begin;
+%rename("_dangerous_terms_end") get_terms_end;
+// in Xapian::Enquire
+%rename("_dangerous_matching_terms_begin") get_matching_terms_begin;
+%rename("_dangerous_matching_terms_end") get_matching_terms_end;
+// in Xapian::Database
+%rename("_dangerous_allterms_begin") allterms_begin;
+%rename("_dangerous_allterms_end") allterms_end;
+// in Xapian::Database
+%rename("_dangerous_postlist_begin") postlist_begin;
+%rename("_dangerous_postlist_end") postlist_end;
+// in Xapian::Database
+%rename("_dangerous_positionlist_begin") positionlist_begin;
+%rename("_dangerous_positionlist_end") positionlist_end;
+// in Xapian::Database
+%rename("_dangerous_valuestream_begin") valuestream_begin;
+%rename("_dangerous_valuestream_end") valuestream_end;
+// in Xapian::Document and Xapian::ValueCountMatchSpy
+%rename("_dangerous_values_begin") values_begin;
+%rename("_dangerous_values_end") values_end;
+// in Xapian::ValueCountMatchSpy
+%rename("_dangerous_top_values_begin") top_values_begin;
+%rename("_dangerous_top_values_end") top_values_end;
+
+
+// MSetIterators are not dangerous, just inconvenient to use within a Ruby
+// idiom.
+%rename ("_begin") begin;
+%rename ("_end") end;
+%rename ("_back") back;
+
+
+
+// Setters
+%rename("collapse_key=") set_collapse_key;
+%rename("cutoff!") set_cutoff;
+%rename("data=") set_data;
+%rename("database=") set_database;
+%rename("default_op=") set_default_op;
+%rename("docid_order=") set_docid_order;
+%rename("document=") set_document;
+%rename("query=") set_query(const Query &);
+%rename("query!") set_query(const Query &, termcount qlen);
+%rename("sort_by_relevance!") set_sort_by_relevance;
+%rename("sort_by_relevance_then_value!") set_sort_by_relevance_then_value;
+%rename("sort_by_value_then_relevance!") set_sort_by_value_then_relevance;
+%rename("sort_by_value!") set_sort_by_value;
+%rename("stemmer=") set_stemmer;
+%rename("stemming_strategy=") set_stemming_strategy;
+%rename("stopper=") set_stopper;
+%rename("weighting_scheme=") set_weighting_scheme;
+
+// Booleans
+%predicate empty;
+
+#define XAPIAN_MIXED_VECTOR_QUERY_INPUT_TYPEMAP
+/*
+ * Check to see what is equivalent to a C++ Vector for the purposes of a Query
+ * instantiation.
+ * At the moment, we take Ruby Arrays.
+ */
+%typemap(typecheck, precedence=500) const vector<Xapian::Query> & {
+    $1 = (TYPE($input) == T_ARRAY);
+
+    /* Says Olly:
+     * Currently, the only wrapped method which takes a Ruby array is the
+     * "extra" constructor Query(OP, ARRAY), where ARRAY can contain any mix of
+     * strings and Query objects.
+     *
+     * If we ever had a method (or function) which had two overloaded forms
+     * only differentiated by what type of array can be passed we'd need to
+     * look at the type of the array element in the typecheck typemaps.
+     */
+}
+
+/*
+ * Convert Ruby Arrays to C++ Vectors for Query instantiation.
+ */
+%typemap(in) const vector<Xapian::Query> & (vector<Xapian::Query> v) {
+    if (TYPE($input) != T_ARRAY) {
+	SWIG_exception(SWIG_ValueError, "expected array of queries");
+    }
+
+    int numitems = RARRAY_LEN($input);
+    v.reserve(numitems);
+    for (int i = 0; i < numitems; ++i) {
+      VALUE arrayEntry = rb_ary_entry($input, i);
+      if (TYPE(arrayEntry) == T_STRING) {
+        v.push_back(Xapian::Query(string(RSTRING_PTR(arrayEntry),
+					 RSTRING_LEN(arrayEntry))));
+      }
+      else {
+        // array element may be a Xapian::Query object. Add it if it is,
+        // otherwise error out.
+        Xapian::Query *subq = 0;
+        if (SWIG_ConvertPtr(arrayEntry, (void **)&subq,
+                            SWIGTYPE_p_Xapian__Query, 0) < 0) {
+          subq = 0;
+        }
+        if (!subq) {
+          SWIG_exception(SWIG_ValueError, "elements of Arrays passed to Query must be either Strings or other Queries");
+        }
+        v.push_back(*subq);            
+      }
+
+    }       
+
+    $1 = &v;
+}
+
+%typemap(directorin) (size_t num_tags, const std::string tags[]) {
+    $input = rb_ary_new();
+    for (size_t i = 0; i != num_tags; ++i) {
+	VALUE str = rb_str_new(tags[i].data(), tags[i].size());
+	rb_ary_push($input, str);
+    }
+}
+
+// For MatchDecider::operator() and ExpandDecider::operator().
+%typemap(directorout) int = bool;
+
+/* vim:set syntax=cpp:set noexpandtab: */

data/xapian.rb

@@ -0,0 +1,315 @@
+# :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.
+# Copyright (C) 2008,2011 Olly Betts
+# Copyright (C) 2010 Richard Boulton
+#
+# 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, :docid
+    
+    def initialize(value, valueno, docid)
+      @value = value
+      @valueno = valueno
+      @docid = docid
+    end # initialize
+
+    def ==(other)
+      return other.is_a?(Xapian::Value) && other.value == @value && other.valueno == @valueno && other.docid == @docid
+    end
+  end # Xapian::Value
+
+  # Refer to the
+  # {Xapian::Document C++ API documentation}[http://xapian.org/docs/apidoc/html/classXapian_1_1Document.html]
+  # for methods not specific to Ruby.
+  #--
+  # 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, 0)
+      }
+    end # values
+
+  end # class Xapian::Document
+
+  # Refer to the
+  # {Xapian::Query C++ API documentation}[http://xapian.org/docs/apidoc/html/classXapian_1_1Query.html]
+  # for methods not specific to Ruby.
+  #--
+  # 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 # terms
+  end # Xapian::Query
+
+  # Refer to the
+  # {Xapian::Enquire C++ API documentation}[http://xapian.org/docs/apidoc/html/classXapian_1_1Enquire.html]
+  # for methods not specific to Ruby.
+  #--
+  # 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 # matching_terms
+  end # Xapian::Enquire
+
+  # Refer to the
+  # {Xapian::MSet C++ API documentation}[http://xapian.org/docs/apidoc/html/classXapian_1_1MSet.html]
+  # for methods not specific to Ruby.
+  #--
+  # 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
+
+  # Refer to the
+  # {Xapian::ESet C++ API documentation}[http://xapian.org/docs/apidoc/html/classXapian_1_1ESet.html]
+  # for methods not specific to Ruby.
+  #--
+  # 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#term() (defined in xapian.i) to ExpandTerm#term()
+        Xapian::ExpandTerm.new(item.term, 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
+
+  # Refer to the
+  # {Xapian::Database C++ API documentation}[http://xapian.org/docs/apidoc/html/classXapian_1_1Database.html]
+  # for methods not specific to Ruby.
+  #--
+  # Wrap some dangerous iterators.
+  class Xapian::Database
+    # Returns an Array of all Xapian::Terms for this database.
+    def allterms(pref = '')
+      Xapian._safelyIterate(self._dangerous_allterms_begin(pref),
+                            self._dangerous_allterms_end(pref)) { |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
+
+    # Returns an Array of Xapian::Value objects for the given slot in the
+    # database.
+    def valuestream(slot)
+      Xapian._safelyIterate(self._dangerous_valuestream_begin(slot),
+                            self._dangerous_valuestream_end(slot)) { |item|
+        Xapian::Value.new(item.value, slot, item.docid)
+      }
+    end # valuestream(slot)
+  end # Xapian::Database
+
+  # Refer to the
+  # {Xapian::ValueCountMatchSpy C++ API documentation}[http://xapian.org/docs/apidoc/html/classXapian_1_1ValueCountMatchSpy.html]
+  # for methods not specific to Ruby.
+  #--
+  # Wrap some dangerous iterators.
+  class Xapian::ValueCountMatchSpy
+    # Returns an Array of all the values seen, in alphabetical order
+    def values()
+      Xapian._safelyIterate(self._dangerous_values_begin(),
+                            self._dangerous_values_end()) { |item|
+        Xapian::Term.new(item.term, 0, item.termfreq)
+      }
+    end # values
+
+    # Returns an Array of the top values seen, by frequency
+    def top_values(maxvalues)
+      Xapian._safelyIterate(self._dangerous_top_values_begin(maxvalues),
+                            self._dangerous_top_values_end(maxvalues)) { |item|
+        Xapian::Term.new(item.term, 0, item.termfreq)
+      }
+    end # top_values
+  end # Xapian::Database
+
+end # Xapian module