mongosphinx 0.1

data/README.rdoc

@@ -0,0 +1,164 @@
+= MongoSphinx
+
+The MongoSphinx library implements an interface between MongoDBand Sphinx 
+supporting MongoMapper to automatically index objects in Sphinx. It tries to
+act as transparent as possible: Just an additional method in MongoMapper
+and some Sphinx configuration are needed to get going.
+
+== Prerequisites
+
+MongoSphinx needs gems MongoMapper and Riddle as well as a running Sphinx
+and a MongoDB installation.
+
+  sudo gem sources -a http://gems.github.com  # Only needed once!
+  sudo gem install riddle
+  sudo gem install mongomapper
+  sudo gem install burke-mongosphinx
+
+No additional configuraton is needed for interfacing with MongoDB: Setup is
+done when MongoMapper is able to talk to the MongoDB server.
+
+A proper "sphinx.conf" file and a script for retrieving index data have to
+be provided for interfacing with Sphinx: Sorry, no UltraSphinx like
+magic... :-) Depending on the amount of data, more than one index may be used
+and indexes may be consolidated from time to time.
+
+This is a sample configuration for a single "main" index:
+
+  searchd {
+    address = 0.0.0.0
+    port = 3312
+
+    log = ./sphinx/searchd.log
+    query_log = ./sphinx/query.log
+    pid_file = ./sphinx/searchd.pid
+  }
+
+  source mongoblog {
+    type = xmlpipe2
+  
+    xmlpipe_command = "rake sphinx:genxml"
+  }
+
+  index mongoblog {
+    source = mongoblog
+
+    charset_type = utf-8
+    path = ./sphinx/sphinx_index_main
+  }
+
+Notice the line "xmlpipe_command =". This is what the indexer runs to generate 
+its input. You can change this to whatever works best for you, but I set it up as 
+a rake task, with the following in `lib/tasks/sphinx.rake` .
+
+Here, :fields is a list of fields to export. Performance tends to suffer if you export
+everything, so you'll probably want to just list the fields you're indexing.
+
+  namespace :sphinx do
+    task :genxml => :environment do
+      puts MongoSphinx::Indexer::XMLDocset.new(Food.all(:fields => 'name')).to_s
+    end
+  end
+
+== Models
+
+Use method <tt>fulltext_index</tt> to enable indexing of a model. The
+default is to index all attributes but it is recommended to provide a list of
+attribute keys.
+
+A side effect of calling this method is, that MongoSphinx overrides the
+default of letting MongoDB create new IDs: Sphinx only allows numeric IDs and
+MongoSphinx forces new objects with the name of the class, a hyphen and an
+integer as ID (e.g. <tt>Post-38497238</tt>). Again: Only these objects are
+indexed due to internal restrictions of Sphinx.
+
+Sample:
+
+  class Post
+    include MongoMapper::Document
+
+    key :title, String
+    key :body, String
+
+    fulltext_index :title, :body
+  end
+
+Add options <tt>:server</tt> and <tt>:port</tt> to <tt>fulltext_index</tt> if
+the Sphinx server to query is running on a different server (defaults to
+"localhost" with port 3312).
+
+Here is a full-featured sample setting additional options:
+
+  fulltext_index :title, :body, :server => 'my.other.server', :port => 3313
+
+== Indexing
+
+Automatically starting the reindexing of objects the moment new objects are
+created can be implemented by adding a filter to the model class:
+    
+ after_save :reindex
+ def reindex
+  `sudo indexer --all --rotate` # Configure sudo to allow this call...
+  end
+
+This or a similar callback should be added to all models needing instant
+indexing. If indexing is not that crucial or load is high, some additional
+checks for the time of the last call should be added. 
+
+Keep in mind that reindexing is not incremental, and xml is generated to pass
+data from mongo to sphinx. It's not a speedy operation on large datasets.
+
+
+== Queries
+
+An additional instance method <tt>by_fulltext_index</tt> is added for each
+fulltext indexed model. This method takes a Sphinx query like
+"foo @title bar", runs it within the context of the current class and returns
+an Array of matching MongoDB documents.
+
+Samples:
+
+  Post.by_fulltext_index('first')
+  => [...]
+
+  post = Post.by_fulltext_index('this is @title post').first
+  post.title
+  => "First Post"
+  post.class
+  => Post
+
+Additional options <tt>:match_mode</tt>, <tt>:limit</tt> and
+<tt>:max_matches</tt> can be provided to customize the behaviour of Riddle.
+Option <tt>:raw</tt> can be set to <tt>true</tt> to do no lookup of the
+document IDs but return the raw IDs instead.
+
+Sample:
+
+  Post.by_fulltext_index('my post', :limit => 100)
+
+== Copyright & License
+
+Copyright (c) 2009 Burke Libbey, Ryan Neufeld
+
+CouchSphinx Copyright (c) 2009 Holtzbrinck Digital GmbH, Jan Ulbrich
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/lib/indexer.rb

@@ -0,0 +1,217 @@
+# MongoSphinx, a full text indexing extension for MongoDB using
+# Sphinx.
+#
+# This file contains the MongoSphinx::Indexer::XMLDocset and
+# MongoSphinx::Indexer::XMLDoc classes.
+
+# Namespace module for the MongoSphinx gem.
+
+module MongoSphinx #:nodoc:
+
+  # Module Indexer contains classes for creating XML input documents for the
+  # indexer. Each Sphinx index consists of a single "sphinx:docset" with any
+  # number of "sphinx:document" tags.
+  #
+  # The XML source can be generated from an array of CouchRest objects or from
+  # an array of Hashes containing at least fields "classname" and "_id"
+  # as returned by MongoDB view "MongoSphinxIndex/couchrests_by_timestamp".
+  #
+  # Sample:
+  #
+  #   rows = [{ 'name' => 'John', 'phone' => '199 43828',
+  #             'classname' => 'Address', '_id' => 'Address-234164'
+  #           },
+  #           { 'name' => 'Sue', 'mobile' => '828 19439',
+  #             'classname' => 'Address', '_id' => 'Address-422433'
+  #          }
+  #   ]
+  #   puts MongoSphinx::Indexer::XMLDocset.new(rows).to_s
+  #
+  #   <?xml version="1.0" encoding="utf-8"?>
+  #   <sphinx:docset>
+  #     <sphinx:schema>
+  #       <sphinx:attr name="csphinx-class" type="multi"/>
+  #       <sphinx:field name="classname"/>
+  #       <sphinx:field name="name"/>
+  #       <sphinx:field name="phone"/>
+  #       <sphinx:field name="mobile"/>
+  #       <sphinx:field name="created_at"/>
+  #     </sphinx:schema>
+  #     <sphinx:document id="234164">
+  #       <csphinx-class>336,623,883,1140</csphinx-class>
+  #       <classname>Address</classname>
+  #       <name><![CDATA[[John]]></name>
+  #       <phone><![CDATA[[199 422433]]></phone>
+  #       <mobile><![CDATA[[]]></mobile>
+  #       <created_at><![CDATA[[]]></created_at>
+  #     </sphinx:document>
+  #     <sphinx:document id="423423">
+  #       <csphinx-class>336,623,883,1140</csphinx-class>
+  #       <classname>Address</classname>
+  #       <name><![CDATA[[Sue]]></name>
+  #       <phone><![CDATA[[]]></phone>
+  #       <mobile><![CDATA[[828 19439]]></mobile>
+  #       <created_at><![CDATA[[]]></created_at>
+  #     </sphinx:document>
+  #   </sphinx:docset>"
+
+  module Indexer
+
+    # Class XMLDocset wraps the XML representation of a document to index. It
+    # contains a complete "sphinx:docset" including its schema definition.
+
+    class XMLDocset
+
+      # Objects contained in document set.
+
+      attr_reader :xml_docs
+
+      # XML generated for opening the document.
+
+      attr_reader :xml_header
+
+      # XML generated for closing the document.
+
+      attr_reader :xml_footer
+
+      # Creates a XMLDocset object from the provided data. It defines a
+      # superset of all fields of the classes to index objects for. The class
+      # names are collected from the provided objects as well.
+      #
+      # Parameters:
+      #
+      # [data] Array with objects of type CouchRest::Document or Hash to create XML for
+
+      def initialize(rows = [])
+        raise ArgumentError, 'Missing class names' if rows.nil?
+
+        xml = '<?xml version="1.0" encoding="utf-8"?>'
+
+        xml << '<sphinx:docset><sphinx:schema>'
+
+        @xml_docs = []
+        classes = []
+
+        rows.each do |row|
+          object = nil
+
+          if row.kind_of? MongoMapper::Document
+            object = row
+          elsif row.kind_of? Hash
+            row = row['value'] if row['classname'].nil?
+
+            if row and (class_name = row['classname'])
+              object = eval(class_name.to_s).new(row) rescue nil
+            end
+          end
+
+          if object and object.sphinx_id
+            classes << object.class if not classes.include? object.class
+            @xml_docs << XMLDoc.from_object(object)
+          end
+        end
+
+        field_names = classes.collect { |clas| clas.fulltext_keys rescue []
+                        }.flatten.uniq
+
+        field_names.each do |key, value|
+          xml << "<sphinx:field name=\"#{key}\"/>"
+        end
+
+        xml << '<sphinx:field name="classname"/>'
+        xml << '<sphinx:attr name="csphinx-class" type="multi"/>'
+
+        xml << '</sphinx:schema>'
+
+        @xml_header = xml
+        @xml_footer = '</sphinx:docset>'
+      end
+
+      # Returns the encoded data as XML.
+      
+      def to_xml
+        return to_s
+      end
+
+      # Returns the encoded data as XML.
+      
+      def to_s
+        return self.xml_header + self.xml_docs.join + self.xml_footer
+      end
+    end
+
+    # Class XMLDoc wraps the XML representation of a single document to index
+    # and contains a complete "sphinx:document" tag.
+
+    class XMLDoc
+
+      # Returns the ID of the encoded data.
+
+      attr_reader :id
+
+      # Returns the class name of the encoded data.
+
+      attr_reader :class_name
+
+      # Returns the encoded data.
+
+      attr_reader :xml
+
+      # Creates a XMLDoc object from the provided CouchRest object.
+      #
+      # Parameters:
+      #
+      # [object] Object to index
+
+      def self.from_object(object)
+        raise ArgumentError, 'Missing object' if object.nil?
+        raise ArgumentError, 'No compatible ID' if (id = object.sphinx_id).nil?
+
+        return new(id, object.class.to_s, object.fulltext_attributes)
+      end
+
+      # Creates a XMLDoc object from the provided ID, class name and data.
+      #
+      # Parameters:
+      #
+      # [id] ID of the object to index
+      # [class_name] Name of the class
+      # [data] Hash with the properties to index
+
+      def initialize(id, class_name, properties)
+        raise ArgumentError, 'Missing id' if id.nil?
+        raise ArgumentError, 'Missing class_name' if class_name.nil?
+
+        xml = "<sphinx:document id=\"#{id}\">"
+
+        xml << '<csphinx-class>'
+        xml << MongoSphinx::MultiAttribute.encode(class_name)
+        xml << '</csphinx-class>'
+        xml << "<classname>#{class_name}</classname>"
+
+        properties.each do |key, value|
+          xml << "<#{key}><![CDATA[[#{value}]]></#{key}>"
+        end
+
+        xml << '</sphinx:document>'
+
+        @xml = xml
+
+        @id = id
+        @class_name = class_name
+      end
+
+      # Returns the encoded data as XML.
+      
+      def to_xml
+        return to_s
+      end
+
+      # Returns the encoded data as XML.
+      
+      def to_s
+        return self.xml
+      end
+    end
+  end
+end

data/lib/mixins/indexer.rb

@@ -0,0 +1,181 @@
+# MongoSphinx, a full text indexing extension for MongoDB/MongoMapper using
+# Sphinx.
+#
+# This file contains the MongoMapper::Mixins::Indexer module which in turn
+# includes MongoMapper::Mixins::Indexer::ClassMethods.
+
+module MongoMapper # :nodoc:
+  module Mixins # :nodoc:
+
+    # Mixin for MongoMapper adding indexing stuff. See class ClassMethods for
+    # details.
+
+    module Indexer #:nodoc:
+
+      # Bootstrap method to include patches with.
+      #
+      # Parameters:
+      #
+      # [base] Class to include class methods of module into
+
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      # Patches to the MongoMapper Document module: Adds the
+      # "fulltext_index" method for enabling indexing and defining the fields
+      # to include as a domain specific extention. This method also assures
+      # the existence of a special design document used to generate indexes
+      # from.
+      # 
+      # An additional save callback sets an ID like "Post-123123" (class name
+      # plus pure numeric ID compatible with Sphinx) for new objects).
+      #
+      # Last but not least method "by_fulltext_index" is defined allowing a
+     
+     # full text search like "foo @title bar" within the context of the
+      # current class.
+      #
+      # Samples:
+      #
+      #   class Post < MongoMapper::Document
+      #     use_database SERVER.default_database
+      # 
+      #     property :title
+      #     property :body
+      #
+      #     fulltext_index :title, :body
+      #   end
+      #
+      #   Post.by_fulltext_index('first')
+      #   => [...]
+      #   post = Post.by_fulltext_index('this is @title post').first
+      #   post.title
+      #   => "First Post"
+      #   post.class
+      #   => Post
+
+      def save_callback()
+        object = self
+        if object.id.nil?
+          idsize = fulltext_opts[:idsize] || 32
+          limit = (1 << idsize) - 1
+          
+          while true
+            id = rand(limit)
+            candidate = "#{self.class.to_s}-#{id}"
+            
+            begin
+              object.class.find(candidate) # Resource not found exception if available
+            rescue MongoMapper::DocumentNotFound
+              object.id = candidate
+              break
+            end
+          end
+        end
+      end
+      
+      
+      
+      module ClassMethods
+
+        # Method for enabling fulltext indexing and for defining the fields to
+        # include.
+        #
+        # Parameters:
+        #
+        # [keys] Array of field keys to include plus options Hash
+        #
+        # Options:
+        #
+        # [:server] Server name (defaults to localhost)
+        # [:port] Server port (defaults to 3312)
+        # [:idsize] Number of bits for the ID to generate (defaults to 32)
+
+        def fulltext_index(*keys)
+          opts = keys.pop if keys.last.is_a?(Hash)
+          opts ||= {} # Handle some options: Future use... :-)
+
+          # Save the keys to index and the options for later use in callback.
+          # Helper method cattr_accessor is already bootstrapped by couchrest
+          # gem. 
+
+          cattr_accessor :fulltext_keys 
+          cattr_accessor :fulltext_opts 
+
+          self.fulltext_keys = keys
+          self.fulltext_opts = opts
+
+          # Overwrite setting of new ID to do something compatible with
+          # Sphinx. If an ID already exists, we try to match it with our 
+          # Schema and cowardly ignore if not.
+
+          before_save :save_callback
+
+        end 
+      
+        # Searches for an object of this model class (e.g. Post, Comment) and
+        # the requested query string. The query string may contain any query 
+        # provided by Sphinx.
+        #
+        # Call MongoMapper::Document.by_fulltext_index() to query
+        # without reducing to a single class type.
+        #
+        # Parameters:
+        #
+        # [query] Query string like "foo @title bar"
+        # [options] Additional options to set
+        #
+        # Options:
+        #
+        # [:match_mode] Optional Riddle match mode (defaults to :extended)
+        # [:limit] Optional Riddle limit (Riddle default)
+        # [:max_matches] Optional Riddle max_matches (Riddle default)
+        # [:sort_by] Optional Riddle sort order (also sets sort_mode to :extended)
+        # [:raw] Flag to return only IDs and do not lookup objects (defaults to false)
+
+        def by_fulltext_index(query, options = {})
+          if self == Document
+            client = Riddle::Client.new
+          else
+            client = Riddle::Client.new(fulltext_opts[:server],
+                     fulltext_opts[:port])
+
+            query = query + " @classname #{self}"
+          end
+
+          client.match_mode = options[:match_mode] || :extended
+
+          if (limit = options[:limit])
+            client.limit = limit
+          end
+
+          if (max_matches = options[:max_matches])
+            client.max_matches = matches
+          end
+
+          if (sort_by = options[:sort_by])
+            client.sort_mode = :extended
+            client.sort_by = sort_by
+          end
+
+          result = client.query(query)
+
+          #TODO
+          if result and result[:status] == 0 and (matches = result[:matches])
+            classname = nil
+            ids = matches.collect do |row|
+              classname = MongoSphinx::MultiAttribute.decode(row[:attributes]['csphinx-class'])
+              (classname + '-' + row[:doc].to_s) rescue nil
+            end.compact
+
+            return ids if options[:raw]
+            return Object.const_get(classname).find(ids)
+          else
+            return []
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mixins/properties.rb

@@ -0,0 +1,64 @@
+# MongoSphinx, a full text indexing extension for MongoDB using
+# Sphinx.
+#
+# This file contains the MongoMapper::Mixins::Properties module.
+
+# Patches to the CouchRest library.
+
+module MongoMapper # :nodoc:
+  module Mixins # :nodoc:
+
+    # Patches to the CouchRest Properties module: Adds the "attributes" method 
+    # plus some fulltext relevant stuff.
+    #
+    # Samples:
+    #
+    #   data = SERVER.default_database.view('CouchSphinxIndex/couchrests_by_timestamp')
+    #   rows = data['rows']
+    #   post = Post.new(rows.first)
+    #
+    #   post.attributes
+    #   => {:tags=>"one, two, three", :updated_at=>Tue Jun 09 14:45:00 +0200 2009,
+    #       :author=>nil, :title=>"First Post",
+    #       :created_at=>Tue Jun 09 14:45:00 +0200 2009,
+    #       :body=>"This is the first post. This is the [...] first post. "}
+    #
+    #   post.fulltext_attributes
+    #   => {:title=>"First Post", :author=>nil,
+    #       :created_at=>Tue Jun 09 14:45:00 +0200 2009
+    #       :body=>"This is the first post. This is the [...] first post. "}
+    #
+    #   post.sphinx_id
+    #   => "921744775"
+    #   post.id
+    #   => "Post-921744775"
+
+    module Properties
+
+      # Returns a Hash of all attributes allowed to be indexed. As a side
+      # effect it sets the fulltext_keys variable if still blank or empty.
+
+      def fulltext_attributes
+        clas = self.class
+
+        if not clas.fulltext_keys or clas.fulltext_keys.empty?
+          clas.fulltext_keys = self.attributes.collect { |k,v| k.intern } 
+        end
+
+        return self.attributes.reject do |k, v|
+          not (clas.fulltext_keys.include? k.intern)
+        end
+      end
+
+      # Returns the numeric part of the document ID (compatible to Sphinx).
+
+      def sphinx_id
+        if (match = self.id.match(/#{self.class}-([0-9]+)/))
+          return match[1]
+        else
+          return nil
+        end
+      end
+    end
+  end
+end

data/lib/multi_attribute.rb

@@ -0,0 +1,57 @@
+# MongoSphinx, a full text indexing extension for MongoDB using
+# Sphinx.
+#
+# This file contains the MongoSphinx::MultiAttribute class.
+
+# Namespace module for the MongoSphinx gem.
+
+module MongoSphinx #:nodoc:
+
+  # Module MultiAttribute implements helpers to translate back and
+  # forth between Ruby Strings and an array of integers suitable for Sphinx
+  # attributes of type "multi".
+  #
+  # Background: Getting an ID as result for a query is OK, but for example to
+  # allow cast safety, we need an aditional attribute. Sphinx supports
+  # attributes which are returned together with the ID, but they behave a
+  # little different than expected: Instead we can use arrays of integers with
+  # ASCII character codes. These values are returned in ascending (!) order of
+  # value (yes, sounds funny but is reasonable from an internal view to
+  # Sphinx). So we mask each byte with 0x0100++ to keep the order...
+  #
+  # Sample:
+  #
+  #   MongoSphinx::MultiAttribute.encode('Hello')
+  #   => "328,613,876,1132,1391"
+  #   MongoSphinx::MultiAttribute.decode('328,613,876,1132,1391')
+  #   => "Hello"
+
+  module MultiAttribute
+
+    # Returns an numeric representation of a Ruby String suitable for "multi"
+    # attributes of Sphinx.
+    #
+    # Parameters:
+    #
+    # [str] String to translate
+
+    def self.encode(str)
+      offset = 0
+      return str.bytes.collect { |c| (offset+= 0x0100) + c }.join(',')
+    end
+
+    # Returns the original MongoDB ID created from a Sphinx ID. Only works if
+    # the ID was created from a MongoDB ID before!
+    #
+    # Parameters:
+    #
+    # [multi] Sphinx "multi" attribute to translate back
+
+    def self.decode(multi)
+      offset = 0
+      multi = multi.split(',') if not multi.kind_of? Array
+
+      return multi.collect {|x| (x.to_i-(offset+=0x0100)).chr}.to_s
+    end
+  end
+end

data/mongosphinx.rb

@@ -0,0 +1,41 @@
+# MongoSphinx, a full text indexing extension for using
+# Sphinx.
+#
+# This file contains the includes implementing this library. Have a look at
+# the README.rdoc as a starting point.
+
+begin
+  require 'rubygems'
+rescue LoadError; end
+require 'mongomapper'
+require 'riddle'
+
+
+module MongoSphinx
+  if (match = __FILE__.match(/mongosphinx-([0-9.-]*)/))
+    VERSION = match[1]
+  else
+    VERSION = 'unknown'
+  end
+end
+
+require 'lib/multi_attribute'
+require 'lib/indexer'
+require 'lib/mixins/indexer'
+require 'lib/mixins/properties'
+
+
+# Include the Indexer mixin from the original Document class of
+# MongoMapper which adds a few methods and allows calling method indexed_with.
+
+module MongoMapper # :nodoc:
+  module Document # :nodoc:
+    include MongoMapper::Mixins::Indexer
+    module InstanceMethods
+      include MongoMapper::Mixins::Properties
+    end
+    module ClassMethods
+      include MongoMapper::Mixins::Indexer::ClassMethods
+    end
+  end
+end

metadata

@@ -0,0 +1,69 @@
+--- !ruby/object:Gem::Specification 
+name: mongosphinx
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Burke Libbey
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-14 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: 
+email: burke@burkelibbey.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- mongosphinx.rb
+- lib/multi_attribute.rb
+- lib/mixins/properties.rb
+- lib/mixins/indexer.rb
+- lib/mixins/.indexer.rb.swp
+- lib/indexer.rb
+has_rdoc: true
+homepage: http://github.com/burke/mongosphinx
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --exclude
+- pkg
+- --exclude
+- tmp
+- --all
+- --title
+- MongoSphinx
+- --main
+- README.rdoc
+require_paths: 
+- .
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: A full text indexing extension for MongoDB using Sphinx.
+test_files: []
+