xapian-full-alaveteli 1.4.11.1 → 1.4.19.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: aa0e74a5c6a9b94919b5a4422e5d67a9c4b8dd9c7efbe77d6a2055046b127fe0
-  data.tar.gz: 5aebc6cfd88c95a0cf2411fb7f60d4fe969e1c19342e1fd5cf80773bba5391b2
+  metadata.gz: 8e8fed588da19179cb47ae5ee05007518161378d565a13b0f3e8a06f573d6043
+  data.tar.gz: 298ab3b30d670a916bdb27ccc84ea33b53c7cc8be620f5a3a4a8b7f545f6cbc0
 SHA512:
-  metadata.gz: d0a5c64ef8a9828b18f1a9f8b8bad96546098fa1763915d3c3d425ea85f11c8eb8c2676b12001e15c7ed1a135d769ef863cebddca6562613c24f3fcc3a0cd6c3
-  data.tar.gz: f852a60d3e923c1f82be28c66155951eb2c191aaa3441d2716fe70c130b03be356bff0fb953553829677fd7972aee8c3f23c1fb616fc3695f35ac058561d2ab8
+  metadata.gz: fa31414a74c2872da5153446fba5ca7254be76143ac112be83471c0aa8473ef53adc656c96868e17443b1ed6692492b875fc19ff187d46f8ca3c55e2bc002807
+  data.tar.gz: 194d4cf6e791abbe1122c42becd6e6512ee4f1f4b62e1a6fdceac5107fb2ebfa77d6b1ec2e8fee5aa6d757ffc3865922353f0238f6606db0054bf4d8f00e99aa

data/Rakefile

@@ -13,7 +13,8 @@ def system!(cmd)
 	system(cmd) or raise
 end
 
-ver = '1.4.11'
+ver = '1.4.19'
+iter = '1'
 core = "xapian-core-#{ver}"
 bindings = "xapian-bindings-#{ver}"
 
@@ -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.4.11.1/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

@@ -44,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
 
@@ -143,16 +145,24 @@ module Xapian
   #--
   # 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, 0)
-      }
+    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
@@ -163,12 +173,25 @@ module Xapian
   #--
   # 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
-      }
+    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
@@ -179,11 +202,11 @@ module Xapian
   class Xapian::Enquire
     # Get matching terms for some document.
     # document can be either a Xapian::DocID or a Xapian::MSetIterator
-    def matching_terms(document)
+    def matching_terms(document, &block)
       Xapian._safelyIterate(self._dangerous_matching_terms_begin(document),
-                            self._dangerous_matching_terms_end(document)) { |item|
-        Xapian::Term.new(item.term, item.wdf)
-      }
+                            self._dangerous_matching_terms_end(document),
+                            lambda { |item| Xapian::Term.new(item.term, item.wdf) },
+                            &block)
     end # matching_terms
   end # Xapian::Enquire
 
@@ -194,12 +217,11 @@ module Xapian
   # MSetIterators are not dangerous, just inconvenient to use within a Ruby
   # programming idiom. So we wrap them.
   class Xapian::MSet
-    def matches
+    def matches(&block)
       Xapian._safelyIterate(self._begin(),
-                            self._end()) { |item|
-        Xapian::Match.new(item.docid, item.document, item.rank, item.weight, item.collapse_count, item.percent)
-      }
-
+                            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
 
@@ -210,14 +232,13 @@ module Xapian
   # ESetIterators are not dangerous, just inconvenient to use within a Ruby
   # programming idiom. So we wrap them.
   class Xapian::ESet
-    def terms
+    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()) { |item|
-	# note: in the ExpandTerm wrapper, we implicitly rename
-	# ESetIterator#term() (defined in xapian-headers.i) to ExpandTerm#term()
-        Xapian::ExpandTerm.new(item.term, item.weight)
-      }
-
+                            self._end(),
+                            lambda { |item| Xapian::ExpandTerm.new(item.term, item.weight) },
+                            &block)
     end # terms
   end # Xapian::ESet
 
@@ -246,47 +267,79 @@ module Xapian
   # Wrap some dangerous iterators.
   class Xapian::Database
     # Returns an Array of all Xapian::Terms for this database.
-    def allterms(pref = '')
+    def allterms(pref = '', &block)
       Xapian._safelyIterate(self._dangerous_allterms_begin(pref),
-                            self._dangerous_allterms_end(pref)) { |item|
-        Xapian::Term.new(item.term, 0, item.termfreq)
-      }
+                            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)
+    def postlist(term, &block)
       Xapian._safelyIterate(self._dangerous_postlist_begin(term),
-                            self._dangerous_postlist_end(term)) { |item|
-        Xapian::Posting.new(item.docid, item.doclength, item.wdf)
-      }
+                            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)
+    def valuestream(slot, &block)
       Xapian._safelyIterate(self._dangerous_valuestream_begin(slot),
-                            self._dangerous_valuestream_end(slot)) { |item|
-        Xapian::Value.new(item.value, slot, item.docid)
-      }
+                            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
@@ -296,19 +349,19 @@ module Xapian
   # Wrap some dangerous iterators.
   class Xapian::ValueCountMatchSpy
     # Returns an Array of all the values seen, in alphabetical order
-    def values()
+    def values(&block)
       Xapian._safelyIterate(self._dangerous_values_begin(),
-                            self._dangerous_values_end()) { |item|
-        Xapian::Term.new(item.term, 0, item.termfreq)
-      }
+                            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)
+    def top_values(maxvalues, &block)
       Xapian._safelyIterate(self._dangerous_top_values_begin(maxvalues),
-                            self._dangerous_top_values_end(maxvalues)) { |item|
-        Xapian::Term.new(item.term, 0, item.termfreq)
-      }
+                            self._dangerous_top_values_end(maxvalues),
+                            lambda { |item| Xapian::Term.new(item.term, 0, item.termfreq) },
+                            &block)
     end # top_values
   end # Xapian::Database
 
@@ -319,14 +372,32 @@ module Xapian
   # Wrap some dangerous iterators.
   class Xapian::LatLongCoords
     # Returns an Array of all the values seen, in alphabetical order
-    def all()
+    def all(&block)
       Xapian._safelyIterate(self._begin(),
-                            self._end()) { |item|
-        item.get_coord()
-      }
+                            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()

data/xapian-full.gemspec

@@ -2,25 +2,25 @@
 
 Gem::Specification.new do |s|
   s.name = %q{xapian-full-alaveteli}
-  s.version = "1.4.11.1"
+  s.version = "1.4.19.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   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{2020-05-20}
+  s.date = %q{2022-12-06}
   s.description = %q{Xapian bindings for Ruby without dependency on system Xapian library}
   s.email = %q{mysociety@alaveteli.org}
   s.extensions = ["Rakefile"]
   s.files = [
      "lib/xapian.rb",
      "Rakefile",
-     "xapian-bindings-1.4.11.tar.xz",
-     "xapian-core-1.4.11.tar.xz",
+     "xapian-bindings-1.4.19.tar.xz",
+     "xapian-core-1.4.19.tar.xz",
      "xapian-full.gemspec",
   ]
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.required_ruby_version = ">= 2.1.0"
+  s.required_ruby_version = ">= 2.7.0"
   s.summary = %q{xapian-core + Ruby xapian-bindings}
 
   if s.respond_to? :specification_version then

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: xapian-full-alaveteli
 version: !ruby/object:Gem::Version
-  version: 1.4.11.1
+  version: 1.4.19.1
 platform: ruby
 authors:
 - Tom Adams
@@ -14,7 +14,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-20 00:00:00.000000000 Z
+date: 2022-12-06 00:00:00.000000000 Z
 dependencies: []
 description: Xapian bindings for Ruby without dependency on system Xapian library
 email: mysociety@alaveteli.org
@@ -25,8 +25,8 @@ extra_rdoc_files: []
 files:
 - Rakefile
 - lib/xapian.rb
-- xapian-bindings-1.4.11.tar.xz
-- xapian-core-1.4.11.tar.xz
+- xapian-bindings-1.4.19.tar.xz
+- xapian-core-1.4.19.tar.xz
 - xapian-full.gemspec
 homepage: https://github.com/mysociety/xapian-full
 licenses: []
@@ -40,14 +40,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.1.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.3.1
 signing_key: 
 specification_version: 3
 summary: xapian-core + Ruby xapian-bindings