couchsphinx 0.1

data/README.rdoc

@@ -0,0 +1,171 @@
+= CouchSphinx
+
+The CouchSphinx library implements an interface between CouchDB and Sphinx 
+supporting CouchRest to automatically index objects in Sphinx. It tries to
+act as transparent as possible: Just an additional method in the CouchRest
+domain specific language and some Sphinx configuration are needed to get
+going.
+
+== Prerequisites
+
+CouchSphinx needs gems CouchRest and Riddle as well as a running Sphinx
+and a CouchDB installation.
+
+  sudo gem sources -a http://gems.github.com  # Only needed once!
+  sudo gem install riddle
+  sudo gem install couchrest
+  sudo gem install ulbrich-couchsphinx
+
+No additional configuraton is needed for interfacing with CouchDB: Setup is
+done when CouchRest is able to talk to the CouchDB 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 couchblog {
+    type = xmlpipe2
+  
+    xmlpipe_command = ./sphinxsource.rb
+  }
+
+  index couchblog {
+    source = couchblog
+
+    charset_type = utf-8
+    path = ./sphinx/sphinx_index_main
+  }
+
+The script "sphinxsource.rb" providing the data to index may vary
+depending on the number of CouchDB instances it talks to. This is a simple
+script interfacing with one single instance:
+
+  #!/usr/bin/env ruby
+
+  require 'rubygems'
+  require 'lib/models' # Depends on location of model files
+
+  data = SERVER.default_database.view('CouchSphinxIndex/couchrests_by_timestamp')
+  rows = data['rows'] rescue []
+
+  puts CouchSphinx::Indexer::XMLDocset.new(rows).to_s
+
+== 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 CouchSphinx overrides the
+default of letting CouchDB create new IDs: Sphinx only allows numeric IDs and
+CouchSphinx 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 < CouchRest::ExtendedDocument
+    use_database SERVER.default_database
+
+    property :title
+    property :body
+
+    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).
+
+If you are sure your Sphinx is compiled with 64-bit support, you may add
+option <tt>:idsize</tt> with value <tt>64</tt> to generate 64-bit IDs for
+CouchDB (defaults to 32-bits).
+
+Here is a full-featured sample setting additional options:
+
+  fulltext_index :title, :body, :server => 'my.other.server', :port => 3313,
+    :idsize => 64
+
+== Indexing
+
+CouchSphinx also adds a new design document to CouchDB: It needs to collect
+all relevant objects for running the Sphinx indexer and adds its own views
+to do so. Have a look at CouchDB design document "CouchSphinxIndex" for
+details.
+
+Automatically starting the reindexing of objects the moment new objects are
+created can be implemented by adding a save_callback to the model class:
+
+  save_callback :after do |object|
+    `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. 
+
+== 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 CouchDB documents. Use
+<tt>CouchRest::ExtendedDocument.by_fulltext_index</tt> if you want to find
+any document matching the query and not only a certain class.
+
+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 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/couchsphinx.rb

@@ -0,0 +1,28 @@
+# CouchSphinx, a full text indexing extension for CouchDB/CouchRest using
+# Sphinx.
+#
+# This file contains the includes implementing this library. Have a look at
+# the README.rdoc as a starting point.
+
+require 'rubygems'
+
+require 'couchrest'
+require 'riddle'
+
+# Version number to use for updating CouchDB design document CouchSphinxIndex
+# if needed.
+
+module CouchSphinx
+  if (match = __FILE__.match(/couchsphinx-([0-9.-]*)/))
+    VERSION = match[1]
+  else
+    VERSION = 'unknown'
+  end
+end
+
+# Require the stuff implementing this library...
+
+require 'lib/multi_attribute'
+require 'lib/indexer'
+require 'lib/mixins/indexer'
+require 'lib/mixins/properties'

data/lib/indexer.rb

@@ -0,0 +1,217 @@
+# CouchSphinx, a full text indexing extension for CouchDB/CouchRest using
+# Sphinx.
+#
+# This file contains the CouchSphinx::Indexer::XMLDocset and
+# CouchSphinx::Indexer::XMLDoc classes.
+
+# Namespace module for the CouchSphinx gem.
+
+module CouchSphinx #: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 "couchrest-type" and "_id"
+  # as returned by CouchDB view "CouchSphinxIndex/couchrests_by_timestamp".
+  #
+  # Sample:
+  #
+  #   rows = [{ 'name' => 'John', 'phone' => '199 43828',
+  #             'couchrest-type' => 'Address', '_id' => 'Address-234164'
+  #           },
+  #           { 'name' => 'Sue', 'mobile' => '828 19439',
+  #             'couchrest-type' => 'Address', '_id' => 'Address-422433'
+  #          }
+  #   ]
+  #   puts CouchSphinx::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="couchrest-type"/>
+  #       <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>
+  #       <couchrest-type>Address</couchrest-type>
+  #       <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>
+  #       <couchrest-type>Address</couchrest-type>
+  #       <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? CouchRest::Document
+            object = row
+          elsif row.kind_of? Hash
+            row = row['value'] if row['couchrest-type'].nil?
+
+            if row and (class_name = row['couchrest-type'])
+              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="couchrest-type"/>'
+        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 << CouchSphinx::MultiAttribute.encode(class_name)
+        xml << '</csphinx-class>'
+        xml << "<couchrest-type>#{class_name}</couchrest-type>"
+
+        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,256 @@
+# CouchSphinx, a full text indexing extension for CouchDB/CouchRest using
+# Sphinx.
+#
+# This file contains the CouchRest::Mixins::Indexer module which in turn
+# includes CouchRest::Mixins::Indexer::ClassMethods.
+
+# Patches to the CouchRest library.
+
+module CouchRest # :nodoc:
+  module Mixins # :nodoc:
+
+    # Mixin for CouchRest 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 CouchRest ExtendedDocument 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 < CouchRest::ExtendedDocument
+      #     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
+
+      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
+
+          # We add a few new functions to CouchDB for retrieving modified
+          # documents...
+
+          assure_existing_couch_index
+
+          # 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.
+
+          save_callback :before do |object|
+            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.get(candidate) # Resource not found exception if available
+                rescue RestClient::ResourceNotFound
+                  object['_id'] = candidate
+                  break
+                end
+              end
+            end
+          end
+        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 CouchRest::ExtendedDocument.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 == ExtendedDocument
+            client = Riddle::Client.new
+          else
+            client = Riddle::Client.new(fulltext_opts[:server],
+                     fulltext_opts[:port])
+
+            query = query + " @couchrest-type #{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)
+
+          if result and result[:status] == 0 and (matches = result[:matches])
+            keys = matches.collect { |row| (CouchSphinx::MultiAttribute.decode(
+                     row[:attributes]['csphinx-class']) +
+                     '-' + row[:doc].to_s) rescue nil }.compact
+
+            return keys if options[:raw]
+            return multi_get(keys)
+          else
+            return []
+          end
+        end
+
+        # Returns objects for all provided keys not reducing lookup to a
+        # certain type. Casts to a CouchRest object if possible.
+        #
+        # Parameters:
+        #
+        # [ids] Array of document IDs to retrieve
+
+        def multi_get(ids)
+          result = CouchRest.post(SERVER.default_database.to_s +
+                   '/_all_docs?include_docs=true', :keys => ids)
+
+          return result['rows'].collect { |row|
+                   row = row['doc'] if row['couchrest-type'].nil?
+
+                   if row and (class_name = row['couchrest-type'])
+                     eval(class_name.to_s).new(row) rescue row
+                   else
+                     row
+                   end
+                 }
+        end
+
+        # Defines a design document with the functions needed to lookup
+        # modified documents. If the current version is to old, a new version 
+        # of the design document is stored.
+
+        def assure_existing_couch_index
+          if (doc = database.get("_design/CouchSphinxIndex") rescue nil)
+            return if (ver = doc['version']) and ver == CouchSphinx::VERSION
+
+            database.delete_doc(doc)
+          end
+
+          all_couchrests = {
+            :map => 'function(doc) {
+              if(doc["couchrest-type"] && (doc["created_at"] || doc["updated_at"])) {
+                var date = doc["updated_at"];
+                
+                if(date == null)
+                  date = doc["created_at"];
+
+                emit(doc._id, doc);
+              }
+            }'
+          }
+
+          couchrests_by_timestamp = {
+            :map => 'function(doc) {
+              if(doc["couchrest-type"] && (doc["created_at"] || doc["updated_at"])) {
+                var date = doc["updated_at"];
+                
+                if(date == null)
+                  date = doc["created_at"];
+
+                emit(Date.parse(date), doc);
+              }
+            }'
+          }
+
+          database.save_doc({
+            "_id" => "_design/CouchSphinxIndex",
+            :lib_version => CouchSphinx::VERSION,
+            :views => {
+              :all_couchrests => all_couchrests,
+              :couchrests_by_timestamp => couchrests_by_timestamp
+            }
+          })
+        end
+      end
+    end
+  end
+end
+
+# Include the Indexer mixin from the original ExtendedDocument class of
+# CouchRest which adds a few methods and allows calling method indexed_with.
+
+module CouchRest # :nodoc:
+  class ExtendedDocument # :nodoc:
+    include CouchRest::Mixins::Indexer
+  end
+end

data/lib/mixins/properties.rb

@@ -0,0 +1,75 @@
+# CouchSphinx, a full text indexing extension for CouchDB/CouchRest using
+# Sphinx.
+#
+# This file contains the CouchRest::Mixins::Properties module.
+
+# Patches to the CouchRest library.
+
+module CouchRest # :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 properties plus the ID of the document.
+
+      def attributes
+        data = {} 
+
+        self.properties.collect { |p|
+          { p.name.intern => self.send(p.name) } }.each { |h|
+            data.merge! h }
+
+        return data
+      end
+
+      # 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.properties.collect { |p| p.name.intern } 
+        end
+
+        return self.attributes.reject { |k, v|
+               not (clas.fulltext_keys.include? k) }
+      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 @@
+# CouchSphinx, a full text indexing extension for CouchDB/CouchRest using
+# Sphinx.
+#
+# This file contains the CouchSphinx::MultiAttribute class.
+
+# Namespace module for the CouchSphinx gem.
+
+module CouchSphinx #: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:
+  #
+  #   CouchSphinx::MultiAttribute.encode('Hello')
+  #   => "328,613,876,1132,1391"
+  #   CouchSphinx::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 CouchDB ID created from a Sphinx ID. Only works if
+    # the ID was created from a CouchDB 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

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: couchsphinx
+version: !ruby/object:Gem::Version 
+  version: "0.1"
+platform: ruby
+authors: 
+- Jan Ulbrich
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-11-04 00:00:00 +01:00
+default_executable: 
+dependencies: []
+
+description: 
+email: jan.ulbrich @nospam@ holtzbrinck.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+files: 
+- README.rdoc
+- couchsphinx.rb
+- lib/multi_attribute.rb
+- lib/mixins/properties.rb
+- lib/mixins/indexer.rb
+- lib/indexer.rb
+has_rdoc: true
+homepage: http://github.com/ulbrich/couchsphinx
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --exclude
+- pkg
+- --exclude
+- tmp
+- --all
+- --title
+- CouchSphinx
+- --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 CouchDB/CouchRest using Sphinx.
+test_files: []
+