xapian-full-alaveteli 1.2.9.5 → 1.4.18.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 02c1290790f5a41e7a2e5a65a09518446cd913c1e19a4deccbfaccd990e8e00b
+  data.tar.gz: 98764e20b7e188648330772069a595bcb51ab03771384dab12383bd3e5a3e3cb
+SHA512:
+  metadata.gz: 03c228c5463c8807b578d86e74e127c4ed564419c67b751ae5892d488bb78dd7de2986b417a57ee9a27b4cc7592f04d82108618062a7a9008605d0703ac240d7
+  data.tar.gz: ca8c2179f614c78a38190855a1bba3d2e74671504731489f842e65f6e2a899ef9299d320865b7082e8048d2bfa3038e381c96a54d73ca812f03eec1b71a60bf1

data/Rakefile

@@ -1,5 +1,5 @@
 require 'rbconfig'
-c = Config::CONFIG
+c = RbConfig::CONFIG
 
 begin
     require 'bundler'
@@ -13,13 +13,14 @@ def system!(cmd)
 	system(cmd) or raise
 end
 
-ver = '1.2.9'
+ver = '1.4.18'
+iter = '1'
 core = "xapian-core-#{ver}"
 bindings = "xapian-bindings-#{ver}"
 
 task :default do
 	[core,bindings].each do |x|
-		system! "tar -xzvf #{x}.tar.gz"
+		system! "tar -xJvf #{x}.tar.xz"
 	end
 
 	prefix = Dir.pwd
@@ -37,7 +38,7 @@ task :default do
 		if have_bundler
 			# Maybe Bundler is building us in a temporary directory, and will move us to
 			# the system ruby gems directory once built.
-			system! "make clean all LDFLAGS='-R#{Bundler.rubygems.gem_dir}/gems/xapian-full-alaveteli-1.2.9.5/lib'"
+			system! "make clean all LDFLAGS='-R#{Bundler.rubygems.gem_dir}/gems/xapian-full-alaveteli-#{ver}.#{iter}/lib'"
 		else
 			system! "make clean all"
 		end

data/lib/xapian.rb

@@ -4,7 +4,8 @@
 # Original version by Paul Legato (plegato@nks.net), 4/20/06.
 #
 # Copyright (C) 2006 Networked Knowledge Systems, Inc.
-# Copyright (C) 2008 Olly Betts
+# Copyright (C) 2008,2011,2019 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
@@ -43,25 +44,27 @@ module Xapian
 
   # iterate over two dangerous iterators (i.e. those that can cause segfaults
   # if used improperly.)
-  # Return the results as an Array.
+  # If block_given? then the results are fed to it one by one, otherwise the
+  # results are returned 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
-    
+  # wrapper is a lambda that returns some appropriate Ruby object to wrap the
+  # results from the underlying Iterator
+  def _safelyIterate(dangerousStart, dangerousEnd, wrapper) #:nodoc:
     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
+    if block_given?
+      while not item.equals(dangerousEnd) do
+        yield wrapper.call(item)
+        item.next()
+      end
+    else
+      retval = Array.new
+      while not item.equals(dangerousEnd) do
+        retval.push(wrapper.call(item))
+        item.next()
+      end
+      return retval
+    end
   end # _safelyIterate
   module_function :_safelyIterate
 
@@ -86,7 +89,7 @@ module Xapian
   # non-iterative data.
   # (MSetIterator is not dangerous, but it is inconvenient to use from a Ruby
   # idiom, so we wrap it..)
-  class Xapian::Match     
+  class Xapian::Match
     attr_accessor :docid, :document, :rank, :weight, :collapse_count, :percent
 
     def initialize(docid, document, rank, weight, collapse_count, percent)
@@ -99,10 +102,9 @@ module Xapian
     end # initialize
 
     def ==(other)
-      return other.is_a?(Xapian::Match) && other.docid == @docid && other.rank == @rank && 
+      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++
@@ -124,82 +126,119 @@ module Xapian
 
   # Ruby wrapper for Xapian::ValueIterator
   class Xapian::Value
-    attr_accessor :value, :valueno
-    
-    def initialize(value, valueno)
+    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
+      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}[https://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)
-      }
+    def terms(&block)
+      Xapian._safelyIterate(self._dangerous_termlist_begin(),
+                            self._dangerous_termlist_end(),
+                            lambda {
+                              |item| Xapian::Term.new(item.term, item.wdf)
+                            },
+                            &block)
     end # terms
 
-    def values
-      Xapian._safelyIterate(self._dangerous_values_begin(), self._dangerous_values_end()) { |item|
-        Xapian::Value.new(item.value, item.valueno)
-      }
-    end # terms
+    def values(&block)
+      Xapian._safelyIterate(self._dangerous_values_begin(),
+                            self._dangerous_values_end(),
+                            lambda {
+                              |item| Xapian::Value.new(item.value,
+                                                       item.valueno,
+                                                       0)
+                            },
+                            &block)
+    end # values
 
   end # class Xapian::Document
 
+  # Refer to the
+  # {Xapian::Query C++ API documentation}[https://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
+    def terms(&block)
+      # termfreq is not supported by TermIterators from Queries
+      Xapian._safelyIterate(self._dangerous_terms_begin(),
+                            self._dangerous_terms_end(),
+                            lambda {
+                              |item| Xapian::Term.new(item.term, item.wdf)
+                            },
+                            &block)
+    end # terms
+
+    def unique_terms(&block)
+      # termfreq is not supported by TermIterators from Queries
+      Xapian._safelyIterate(self._dangerous_unique_terms_begin(),
+                            self._dangerous_unique_terms_end(),
+                            lambda {
+                              |item| Xapian::Term.new(item.term, item.wdf)
+                            },
+                            &block)
+    end # unique_terms
   end # Xapian::Query
 
+  # Refer to the
+  # {Xapian::Enquire C++ API documentation}[https://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
+    def matching_terms(document, &block)
+      Xapian._safelyIterate(self._dangerous_matching_terms_begin(document),
+                            self._dangerous_matching_terms_end(document),
+                            lambda { |item| Xapian::Term.new(item.term, item.wdf) },
+                            &block)
+    end # matching_terms
   end # Xapian::Enquire
 
+  # Refer to the
+  # {Xapian::MSet C++ API documentation}[https://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)
-      }
-
+    def matches(&block)
+      Xapian._safelyIterate(self._begin(),
+                            self._end(),
+                            lambda { |item| Xapian::Match.new(item.docid, item.document, item.rank, item.weight, item.collapse_count, item.percent) },
+                            &block)
     end # matches
   end # Xapian::MSet
 
+  # Refer to the
+  # {Xapian::ESet C++ API documentation}[https://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)
-      }
-
+    def terms(&block)
+      # note: in the ExpandTerm wrapper, we implicitly rename
+      # ESetIterator#term() (defined in xapian-headers.i) to ExpandTerm#term()
+      Xapian._safelyIterate(self._begin(),
+                            self._end(),
+                            lambda { |item| Xapian::ExpandTerm.new(item.term, item.weight) },
+                            &block)
     end # terms
   end # Xapian::ESet
 
@@ -221,45 +260,148 @@ module Xapian
     end
   end # Xapian::Posting
 
+  # Refer to the
+  # {Xapian::Database C++ API documentation}[https://xapian.org/docs/apidoc/html/classXapian_1_1Database.html]
+  # for methods not specific to Ruby.
   #--
-  # Wrap some dangerous iterators..
+  # 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)
-      }
+    def allterms(pref = '', &block)
+      Xapian._safelyIterate(self._dangerous_allterms_begin(pref),
+                            self._dangerous_allterms_end(pref),
+                            lambda { |item| Xapian::Term.new(item.term, 0, item.termfreq) },
+                            &block)
     end # allterms
 
+    # Returns an Array of all metadata keys for this database.
+    def metadata_keys(pref = '', &block)
+      Xapian._safelyIterate(self._dangerous_metadata_keys_begin(pref),
+                            self._dangerous_metadata_keys_end(pref),
+                            lambda { |item| item.term },
+                            &block)
+    end # metadata_keys
+
     # 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)
-      }      
+    def postlist(term, &block)
+      Xapian._safelyIterate(self._dangerous_postlist_begin(term),
+                            self._dangerous_postlist_end(term),
+                            lambda { |item| Xapian::Posting.new(item.docid, item.doclength, item.wdf) },
+                            &block)
     end # postlist(term)
 
     # Returns an Array of Terms for the given docid.
-    def termlist(docid)
+    def termlist(docid, &block)
       Xapian._safelyIterate(self._dangerous_termlist_begin(docid),
-                            self._dangerous_termlist_end(docid)) { |item|
-        Xapian::Term.new(item.term, item.wdf, item.termfreq)
-      }
+                            self._dangerous_termlist_end(docid),
+                            lambda { |item| Xapian::Term.new(item.term, item.wdf, item.termfreq) },
+                            &block)
     end # termlist(docid)
-    
 
-    # Returns an Array of Xapian::Termpos objects for the given term (a String)
+    # Returns an Array of term positions for the given term (a String)
     # in the given docid.
-    def positionlist(docid, term)
+    def positionlist(docid, term, &block)
       Xapian._safelyIterate(self._dangerous_positionlist_begin(docid, term),
-                            self._dangerous_positionlist_end(docid, term)) { |item|
-        item.termpos
-      }
+                            self._dangerous_positionlist_end(docid, term),
+                            lambda { |item| item.termpos },
+                            &block)
     end # positionlist
 
+    # Returns an Array of Xapian::Value objects for the given slot in the
+    # database.
+    def valuestream(slot, &block)
+      Xapian._safelyIterate(self._dangerous_valuestream_begin(slot),
+                            self._dangerous_valuestream_end(slot),
+                            lambda { |item| Xapian::Value.new(item.value, slot, item.docid) },
+                            &block)
+    end # valuestream(slot)
+
+    # Returns an Array of Xapian::Term objects for the spelling dictionary.
+    def spellings(&block)
+      Xapian._safelyIterate(self._dangerous_spellings_begin(),
+                            self._dangerous_spellings_end(),
+                            lambda { |item| Xapian::Term.new(item.term, 0, item.termfreq) },
+                            &block)
+    end # spellings
+
+    # Returns an Array of synonyms of the given term.
+    def synonyms(term, &block)
+      Xapian._safelyIterate(self._dangerous_synonyms_begin(term),
+                            self._dangerous_synonyms_end(term),
+                            lambda { |item| item.term },
+                            &block)
+    end # synonyms
+
+    # Returns an Array of terms with synonyms.
+    def synonym_keys(&block)
+      Xapian._safelyIterate(self._dangerous_synonym_keys_begin(),
+                            self._dangerous_synonym_keys_end(),
+                            lambda { |item| item.term },
+                            &block)
+    end # synonym_keys
   end # Xapian::Database
 
+  # Refer to the
+  # {Xapian::ValueCountMatchSpy C++ API documentation}[https://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(&block)
+      Xapian._safelyIterate(self._dangerous_values_begin(),
+                            self._dangerous_values_end(),
+                            lambda { |item| Xapian::Term.new(item.term, 0, item.termfreq) },
+                            &block)
+    end # values
+
+    # Returns an Array of the top values seen, by frequency
+    def top_values(maxvalues, &block)
+      Xapian._safelyIterate(self._dangerous_top_values_begin(maxvalues),
+                            self._dangerous_top_values_end(maxvalues),
+                            lambda { |item| Xapian::Term.new(item.term, 0, item.termfreq) },
+                            &block)
+    end # top_values
+  end # Xapian::Database
+
+  # Refer to the
+  # {Xapian::LatLongCoords C++ API documentation}[https://xapian.org/docs/apidoc/html/classXapian_1_1LatLongCoords.html]
+  # for methods not specific to Ruby.
+  #--
+  # Wrap some dangerous iterators.
+  class Xapian::LatLongCoords
+    # Returns an Array of all the values seen, in alphabetical order
+    def all(&block)
+      Xapian._safelyIterate(self._begin(),
+                            self._end(),
+                            lambda { |item| item.get_coord() },
+                            &block)
+    end # allterms
+  end # Xapian::LatLongCoords
+
+  class Xapian::QueryParser
+    # Returns an Array of all words in the query ignored as stopwords.
+    def stoplist(&block)
+      Xapian._safelyIterate(self._dangerous_stoplist_begin(),
+                            self._dangerous_stoplist_end(),
+                            lambda { |item| item.term },
+                            &block)
+    end # stoplist
+
+    # Returns an Array of all words in the query which stem to a given term.
+    def unstem(term, &block)
+      Xapian._safelyIterate(self._dangerous_unstem_begin(term),
+                            self._dangerous_unstem_end(term),
+                            lambda { |item| item.term },
+                            &block)
+    end # unstem
+  end # Xapian::QueryParser
+
+  # Compatibility wrapping for Xapian::BAD_VALUENO (wrapped as a constant since
+  # xapian-bindings 1.4.10).
+  def Xapian::BAD_VALUENO()
+    return Xapian::BAD_VALUENO
+  end
 
 end # Xapian module

data/xapian-full.gemspec

@@ -2,33 +2,30 @@
 
 Gem::Specification.new do |s|
   s.name = %q{xapian-full-alaveteli}
-  s.version = "1.2.9.5"
+  s.version = "1.4.18.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Tom Adams", "Rich Lane", "Seb Bacon"]
-  s.date = %q{2012-06-01}
+  s.authors = ["Tom Adams", "Rich Lane", "Seb Bacon", "Alexey Pisarenko", "Louise Crow", "Ian Chard", "Sam Pearson"]
+  s.homepage = %q{https://github.com/mysociety/xapian-full}
+  s.date = %q{2021-02-10}
   s.description = %q{Xapian bindings for Ruby without dependency on system Xapian library}
-  s.email = %q{rlane@club.cc.cmu.edu}
+  s.email = %q{mysociety@alaveteli.org}
   s.extensions = ["Rakefile"]
   s.files = [
      "lib/xapian.rb",
      "Rakefile",
-     "xapian-bindings-1.2.9.tar.gz",
-     "xapian-core-1.2.9.tar.gz",
+     "xapian-bindings-1.4.18.tar.xz",
+     "xapian-core-1.4.18.tar.xz",
      "xapian-full.gemspec",
   ]
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.3}
+  s.required_ruby_version = ">= 2.1.0"
   s.summary = %q{xapian-core + Ruby xapian-bindings}
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
     s.specification_version = 3
-
-    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
-    else
-    end
   else
   end
 end

metadata

@@ -1,74 +1,54 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: xapian-full-alaveteli
-version: !ruby/object:Gem::Version 
-  hash: 97
-  prerelease: 
-  segments: 
-  - 1
-  - 2
-  - 9
-  - 5
-  version: 1.2.9.5
+version: !ruby/object:Gem::Version
+  version: 1.4.18.1
 platform: ruby
-authors: 
+authors:
 - Tom Adams
 - Rich Lane
 - Seb Bacon
+- Alexey Pisarenko
+- Louise Crow
+- Ian Chard
+- Sam Pearson
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2012-06-01 00:00:00 +01:00
-default_executable: 
+date: 2021-02-10 00:00:00.000000000 Z
 dependencies: []
-
 description: Xapian bindings for Ruby without dependency on system Xapian library
-email: rlane@club.cc.cmu.edu
+email: mysociety@alaveteli.org
 executables: []
-
-extensions: 
+extensions:
 - Rakefile
 extra_rdoc_files: []
-
-files: 
-- lib/xapian.rb
+files:
 - Rakefile
-- xapian-bindings-1.2.9.tar.gz
-- xapian-core-1.2.9.tar.gz
+- lib/xapian.rb
+- xapian-bindings-1.4.18.tar.xz
+- xapian-core-1.4.18.tar.xz
 - xapian-full.gemspec
-has_rdoc: true
-homepage: 
+homepage: https://github.com/mysociety/xapian-full
 licenses: []
-
+metadata: {}
 post_install_message: 
-rdoc_options: 
-- --charset=UTF-8
-require_paths: 
+rdoc_options:
+- "--charset=UTF-8"
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  none: false
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: 2.1.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      hash: 3
-      segments: 
-      - 0
-      version: "0"
+    - !ruby/object:Gem::Version
+      version: '0'
 requirements: []
-
-rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 3
 summary: xapian-core + Ruby xapian-bindings
 test_files: []
-