shanna-dm-sphinx-adapter 0.5 → 0.6

data/Manifest.txt

@@ -7,27 +7,20 @@ dm-sphinx-adapter.gemspec
 lib/dm-sphinx-adapter.rb
 lib/dm-sphinx-adapter/adapter.rb
 lib/dm-sphinx-adapter/attribute.rb
-lib/dm-sphinx-adapter/client.rb
-lib/dm-sphinx-adapter/config.rb
-lib/dm-sphinx-adapter/config_parser.rb
 lib/dm-sphinx-adapter/index.rb
 lib/dm-sphinx-adapter/query.rb
 lib/dm-sphinx-adapter/resource.rb
-test/files/dm_sphinx_adapter_test.sql
-test/files/resource_explicit.rb
-test/files/resource_resource.rb
-test/files/resource_searchable.rb
-test/files/resource_storage_name.rb
-test/files/resource_vanilla.rb
-test/files/sphinx.conf
+lib/riddle.rb
+lib/riddle/client.rb
+lib/riddle/client/filter.rb
+lib/riddle/client/message.rb
+lib/riddle/client/response.rb
+test/files/model.rb
+test/files/mysql5.sphinx.conf
+test/files/mysql5.sql
+test/helper.rb
 test/test_adapter.rb
-test/test_adapter_explicit.rb
-test/test_adapter_resource.rb
-test/test_adapter_searchable.rb
-test/test_adapter_vanilla.rb
-test/test_client.rb
-test/test_config.rb
-test/test_config_parser.rb
+test/test_attribute.rb
+test/test_index.rb
 test/test_query.rb
-test/test_type_attribute.rb
-test/test_type_index.rb
+test/test_resource.rb

data/README.txt

@@ -1,6 +1,7 @@
 = DataMapper Sphinx Adapter
 
-* http://rubyforge.org/projects/dm-sphinx/
+* http://dm-sphinx.rubyforge.org
+* http://rubyforge.org/projects/dm-sphinx
 * http://github.com/shanna/dm-sphinx-adapter/tree/master
 
 == Description
@@ -10,15 +11,13 @@ A DataMapper Sphinx adapter.
 == Dependencies
 
 * dm-core           ~> 0.9.7
-* riddle            ~> 0.9
-* daemon_controller ~> 0.2   (optional)
 * dm-is-searchable  ~> 0.9.7 (optional)
 
 I'd recommend using the dm-more plugin dm-is-searchable instead of fetching the document id's yourself.
 
 == Install
 
-* Via git: git clone git://github.com/shanna/iso-country-codes.git
+* Via git: git clone git://github.com/shanna/dm-sphinx-adapter.git
 * Via gem: gem install shanna-dm-sphinx-adapter -s http://gems.github.com
 
 == Synopsis
@@ -26,9 +25,10 @@ I'd recommend using the dm-more plugin dm-is-searchable instead of fetching the
 DataMapper uses URIs or a connection has to connect to your data-stores. In this case the sphinx search daemon
 <tt>searchd</tt>.
 
-On its own this adapter will only return an array of document hashes when queried. The DataMapper library dm-more
-however provides dm-is-searchable, a common interface to search one adapter and load documents from another. My
-preference is to use this adapter in tandem with dm-is-searchable.
+On its own this adapter will only return an array of document hashes when queried. The DataMapper library
+<tt>dm-is-searchable</tt> however provides a common interface to search one adapter and load documents from another. My
+preference is to use this adapter in tandem with <tt>dm-is-searchable</tt>. See further examples in the synopsis for
+usage with <tt>dm-is-searchable</tt>.
 
 Like all DataMapper adapters you can connect with a Hash or URI.
 
@@ -40,7 +40,6 @@ The breakdown is:
   - adapter Must be :sphinx
   - host    Hostname (default: localhost)
   - port    Optional port number (default: 3312)
-  - config  Optional but strongly recommended path to sphinx config file.
 
 Alternatively supply a Hash:
   DataMapper.setup(:search, {
@@ -48,7 +47,6 @@ Alternatively supply a Hash:
     :config   => './sphinx.conf' # optional. Recommended though.
     :host     => 'localhost',    # optional. Default: localhost
     :port     => 3312            # optional. Default: 3312
-    :managed  => true            # optional. Self managed searchd server using daemon_controller.
   }
 
 === DataMapper
@@ -70,7 +68,21 @@ Alternatively supply a Hash:
   ids   = docs.map{|doc| doc[:id]}
   items = Item.all(:id => ids) # Search :default for all the document id's returned by sphinx.
 
-=== DataMapper and Is Searchable
+=== DataMapper and IsSearchable
+
+IsSearchable is a DataMapper plugin that provides a common search interface when searching from one adapter and reading
+documents from another.
+
+IsSearchable will read resources from your <tt>:default</tt> repository on behalf of a search adapter such as
+<tt>dm-sphinx-adapter</tt> and <tt>dm-ferret-adapter</tt>. This saves some of the grunt work (as shown in the previous
+example) by mapping the resulting document id's from a search with your <tt>:search</tt> adapter into a suitable
+<tt>#first</tt> or <tt>#all</tt> query for your <tt>:default</tt> repository.
+
+IsSearchable adds a single class method to your resource. The first argument is a <tt>Hash</tt> of
+<tt>DataMapper::Query</tt> conditions to pass to your search adapter (in this case <tt>dm-sphinx-adapter</tt>). An
+optional second <tt>Hash</tt> of <tt>DataMapper::Query</tt> conditions can also be passed and will be appended to the
+query on your <tt>:default</tt> database. This can be handy if you need to add extra exclusions that aren't possible
+using <tt>dm-sphinx-adapter</tt> such as <tt>#gt</tt> or <tt>#lt</tt> conditions.
 
   require 'rubygems'
   require 'dm-core'
@@ -93,7 +105,7 @@ Alternatively supply a Hash:
   # Fire up your sphinx search daemon and start searching.
   items = Item.search(:name => 'barney') # Search 'items' index for '@name barney'
 
-=== Merb, DataMapper and Is Searchable
+=== Merb, DataMapper and IsSearchable
 
   # config/init.rb
   dependency 'dm-is-searchable'
@@ -121,13 +133,12 @@ Alternatively supply a Hash:
   # Fire up your sphinx search daemon and start searching.
   Item.search(:name => 'barney') # Search 'items' index for '@name barney'
 
-=== DataMapper::SphinxResource
+=== DataMapper, IsSearchable and DataMapper::SphinxResource
 
 For finer grained control you can include DataMapper::SphinxResource. For instance you can search one or more indexes
 and sort, include or exclude by attributes defined in your sphinx configuration:
 
   class Item
-    include DataMapper::Resource # Optional, included by SphinxResource if you leave it out yourself.
     include DataMapper::SphinxResource
     property :id, Serial
     property :name, String
@@ -148,28 +159,16 @@ and sort, include or exclude by attributes defined in your sphinx configuration:
 
 == Sphinx Configuration
 
-Though you don't have to supply the sphinx configuration file to dm-sphinx-adapter I'd recommend doing it anyway.
-It's more DRY since all searchd/indexer options can be read straight from the configuration.
-
-  DataMapper.setup(:search, :adapter => 'sphinx', :config => '/path/to/sphinx.conf')
-  DataMapper.setup(:search, 'sphinx://localhost/path/to/sphinx.conf')
-
-If your sphinx.conf lives in either of the default locations /usr/local/etc/sphinx.conf or ./sphinx.conf then you
-only need to supply:
-
-  DataMapper.setup(:search, :adapter => 'sphinx')
+No limitations, restrictions or requirement are imposed on your sphinx configuration. The adapter will not generate nor
+overwrite your finely crafted config file.
 
 == Searchd
 
-As of 0.2 I've added a managed searchd option using daemon_controller. It may come in handy if you only use God, Monit
-or whatever in production. Use the Hash form of DataMapper#setup and supply the option :managed with a true value and
-daemon_controller will start searchd on demand.
-
-It is already strongly encouraged but you will need to specify the path to your sphinx configuration file in order for
-searchd to run. See Sphinx Configuration, DataMapper::Adapters::Sphinx::ManagedClient.
+To keep things simple, this adapter does not manage your sphinx server. Try one of these fine offerings:
 
-The daemon_controller library can be found only on github, not rubyforge.
-See http://github.com/FooBarWidget/daemon_controller/tree/master
+* god[http://god.rubyforge.org]
+* daemon_controller[http://github.com/FooBarWidget/daemon_controller/tree/master]
+* monit[http://www.tildeslash.com/monit]
 
 == Indexer and Live(ish) updates.
 
@@ -182,13 +181,6 @@ For reliable live(ish) updates in a main + delta scheme it's probably best you s
 Andrew (Shodan) Aksyonoff of Sphinx suggests a cronjob or alternatively if you need even less lag to "run indexer in
 an endless loop, with a few seconds of sleep in between to allow searchd some headroom to pick up the changes".
 
-== Todo
-
-* Loads of documentation. Most of it is unchecked YARD at the moment.
-* Add DataMapper::Adapters::Sphinx::Client#attribute_set to allow attribute modification on one or more indexes. It's
-  the only thing missing if you understand the pitfalls and still want to add thinking-sphinx like delta indexing to
-  your resource.
-
 == Contributing
 
 Go nuts. Just send me a pull request (github or otherwise) when you are happy with your code.

data/Rakefile

@@ -3,11 +3,10 @@
 require 'rubygems'
 require 'hoe'
 
-Hoe.new('dm-sphinx-adapter', '0.5') do |p|
+Hoe.new('dm-sphinx-adapter', '0.6') do |p|
   p.developer('Shane Hanna', 'shane.hanna@gmail.com')
   p.extra_deps = [
-    ['dm-core', '~> 0.9.7'],
-    ['riddle',  '~> 0.9']
+    ['dm-core', '~> 0.9.7']
   ]
 end
 

data/dm-sphinx-adapter.gemspec

@@ -2,23 +2,23 @@
 
 Gem::Specification.new do |s|
   s.name = %q{dm-sphinx-adapter}
-  s.version = "0.5"
+  s.version = "0.6"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Shane Hanna"]
-  s.date = %q{2008-12-01}
+  s.date = %q{2008-12-13}
   s.description = %q{A DataMapper Sphinx adapter.}
   s.email = ["shane.hanna@gmail.com"]
   s.extra_rdoc_files = ["History.txt", "LICENCE.txt", "Manifest.txt", "README.txt"]
-  s.files = ["History.txt", "LICENCE.txt", "Manifest.txt", "README.txt", "Rakefile", "dm-sphinx-adapter.gemspec", "lib/dm-sphinx-adapter.rb", "lib/dm-sphinx-adapter/adapter.rb", "lib/dm-sphinx-adapter/attribute.rb", "lib/dm-sphinx-adapter/client.rb", "lib/dm-sphinx-adapter/config.rb", "lib/dm-sphinx-adapter/config_parser.rb", "lib/dm-sphinx-adapter/index.rb", "lib/dm-sphinx-adapter/query.rb", "lib/dm-sphinx-adapter/resource.rb", "test/files/dm_sphinx_adapter_test.sql", "test/files/resource_explicit.rb", "test/files/resource_resource.rb", "test/files/resource_searchable.rb", "test/files/resource_storage_name.rb", "test/files/resource_vanilla.rb", "test/files/sphinx.conf", "test/test_adapter.rb", "test/test_adapter_explicit.rb", "test/test_adapter_resource.rb", "test/test_adapter_searchable.rb", "test/test_adapter_vanilla.rb", "test/test_client.rb", "test/test_config.rb", "test/test_config_parser.rb", "test/test_query.rb", "test/test_type_attribute.rb", "test/test_type_index.rb"]
+  s.files = ["History.txt", "LICENCE.txt", "Manifest.txt", "README.txt", "Rakefile", "dm-sphinx-adapter.gemspec", "lib/dm-sphinx-adapter.rb", "lib/dm-sphinx-adapter/adapter.rb", "lib/dm-sphinx-adapter/attribute.rb", "lib/dm-sphinx-adapter/index.rb", "lib/dm-sphinx-adapter/query.rb", "lib/dm-sphinx-adapter/resource.rb", "lib/riddle.rb", "lib/riddle/client.rb", "lib/riddle/client/filter.rb", "lib/riddle/client/message.rb", "lib/riddle/client/response.rb", "test/files/model.rb", "test/files/mysql5.sphinx.conf", "test/files/mysql5.sql", "test/helper.rb", "test/test_adapter.rb", "test/test_attribute.rb", "test/test_index.rb", "test/test_query.rb", "test/test_resource.rb"]
   s.has_rdoc = true
-  s.homepage = %q{http://rubyforge.org/projects/dm-sphinx/}
+  s.homepage = %q{http://dm-sphinx.rubyforge.org}
   s.rdoc_options = ["--main", "README.txt"]
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{dm-sphinx-adapter}
-  s.rubygems_version = %q{1.3.0}
+  s.rubygems_version = %q{1.3.1}
   s.summary = %q{A DataMapper Sphinx adapter.}
-  s.test_files = ["test/test_adapter.rb", "test/test_adapter_explicit.rb", "test/test_adapter_resource.rb", "test/test_adapter_searchable.rb", "test/test_adapter_vanilla.rb", "test/test_client.rb", "test/test_config.rb", "test/test_config_parser.rb", "test/test_query.rb", "test/test_type_attribute.rb", "test/test_type_index.rb"]
+  s.test_files = ["test/test_adapter.rb", "test/test_attribute.rb", "test/test_index.rb", "test/test_query.rb", "test/test_resource.rb"]
 
   if s.respond_to? :specification_version then
     current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
@@ -26,16 +26,13 @@ Gem::Specification.new do |s|
 
     if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
       s.add_runtime_dependency(%q<dm-core>, ["~> 0.9.7"])
-      s.add_runtime_dependency(%q<riddle>, ["~> 0.9"])
       s.add_development_dependency(%q<hoe>, [">= 1.8.2"])
     else
       s.add_dependency(%q<dm-core>, ["~> 0.9.7"])
-      s.add_dependency(%q<riddle>, ["~> 0.9"])
       s.add_dependency(%q<hoe>, [">= 1.8.2"])
     end
   else
     s.add_dependency(%q<dm-core>, ["~> 0.9.7"])
-    s.add_dependency(%q<riddle>, ["~> 0.9"])
     s.add_dependency(%q<hoe>, [">= 1.8.2"])
   end
 end

data/lib/dm-sphinx-adapter/adapter.rb

@@ -1,7 +1,5 @@
 require 'benchmark'
 
-# TODO: I think perhaps I should move all the query building code to a lib of its own.
-
 module DataMapper
   module Adapters
     module Sphinx
@@ -24,60 +22,83 @@ module DataMapper
       #   - adapter Must be :sphinx
       #   - host    Hostname (default: localhost)
       #   - port    Optional port number (default: 3312)
-      #   - config  Optional but recommended path to sphinx config file.
       #
       # Alternatively supply a Hash:
       #   DataMapper.setup(:search, {
       #     :adapter  => 'sphinx',       # required
-      #     :config   => './sphinx.conf' # optional. Recommended though.
       #     :host     => 'localhost',    # optional. Default: localhost
       #     :port     => 3312            # optional. Default: 3312
-      #     :managed  => true            # optional. Self managed searchd server using daemon_controller.
       #   })
       class Adapter < AbstractAdapter
-        ##
-        # Initialize the sphinx adapter.
+
+        # ==== See
+        # * DataMapper::Adapters::AbstractAdapter
         #
-        # @param [URI, DataObject::URI, Addressable::URI, String, Hash, Pathname] uri_or_options
-        # @see   DataMapper::Adapters::Sphinx::Config
-        # @see   DataMapper::Adapters::Sphinx::Client
+        # ==== Parameters
+        # uri_or_options<URI, DataObject::URI, Addressable::URI, String, Hash, Pathname>::
+        #   DataMapper uri or options hash.
         def initialize(name, uri_or_options)
-          super
-
-          managed = !!(uri_or_options.kind_of?(Hash) && uri_or_options[:managed])
-          @client  = managed ? ManagedClient.new(uri_or_options) : Client.new(uri_or_options)
+          options = normalize_options(uri_or_options)
+          @client = Riddle::Client.new(options.delete(:host), options.delete(:port))
+          options.each{|k, v| @client.method("#{k}=".to_sym).call(v) if @client.respond_to?("#{k}=".to_sym)}
         end
 
-        ##
-        # Interaction with searchd and indexer.
-        #
-        # @see DataMapper::Adapters::Sphinx::Client
-        # @see DataMapper::Adapters::Sphinx::ManagedClient
-        attr_reader :client
-
         def create(resources) #:nodoc:
-          true
+          0
         end
 
         def delete(query) #:nodoc:
-          true
+          0
         end
 
+        # Query your Sphinx repository and return all matching documents.
+        #
+        # ==== Notes
+        #
+        # These methods are public but normally called indirectly through DataMapper::Resource#get,
+        # DataMapper::Resource#first or DataMapper::Resource#all.
+        #
+        # ==== Parameters
+        # query<DataMapper::Query>:: The query object.
+        #
+        # ==== Returns
+        # Array<Hash>:: An array of document hashes. <tt>[{:id => 1}, {:id => 2}]</tt>
+        # Array<>::     An empty array if no documents match.
         def read_many(query)
           read(query)
         end
 
+        # Query your Sphinx repository and return the first document matched.
+        #
+        # ==== Notes
+        #
+        # These methods are public but normally called indirectly through DataMapper::Resource#get,
+        # DataMapper::Resource#first or DataMapper::Resource#all.
+        #
+        # ==== Parameters
+        # query<DataMapper::Query>:: The query object.
+        #
+        # ==== Returns
+        # Hash:: An document hash of the first document matched. <tt>{:id => 1}</tt>
+        # Nil::  If no documents match.
         def read_one(query)
           read(query).first
         end
 
         protected
-          ##
           # List sphinx indexes to search.
+          #
           # If no indexes are explicitly declared using DataMapper::Adapters::Sphinx::Resource then the default storage
           # name is used.
           #
-          # @see DataMapper::Adapters::Sphinx::Resource#sphinx_indexes
+          # ==== See
+          # * DataMapper::Adapters::Sphinx::Resource::ClassMethods#sphinx_indexes
+          #
+          # ==== Parameters
+          # model<DataMapper::Model>:: The DataMapper::Model.
+          #
+          # ==== Returns
+          # Array<DataMapper::Adapters::Sphinx::Index>:: Index objects from the model.
           def indexes(model)
             indexes = model.sphinx_indexes(repository(self.name).name) if model.respond_to?(:sphinx_indexes)
             if indexes.nil? or indexes.empty?
@@ -86,71 +107,57 @@ module DataMapper
             indexes
           end
 
-          ##
-          # List sphinx delta indexes to search.
-          #
-          # @see DataMapper::Adapters::Sphinx::Resource#sphinx_indexes
-          def delta_indexes(model)
-            indexes(model).find_all{|i| i.delta?}
-          end
-
-          ##
           # Query sphinx for a list of document IDs.
           #
-          # @param [DataMapper::Query]
+          # ==== Parameters
+          # query<DataMapper::Query>:: The query object.
+          #
+          # ==== Returns
+          # Array<Hash>:: An array of document hashes. <tt>[{:id => 1}, {:id => 2}]</tt>
+          # Array<>::     An empty array if no documents match.
           def read(query)
             from    = indexes(query.model).map{|index| index.name}.join(', ')
             search  = Sphinx::Query.new(query).to_s
-            options = {
-              :match_mode => :extended, # TODO: Modes!
-              :filters    => search_filters(query) # By attribute.
-            }
-            options[:limit]  = query.limit.to_i  if query.limit
-            options[:offset] = query.offset.to_i if query.offset
+
+            client            = @client.dup
+            client.match_mode = :extended
+            client.filters    = search_filters(query) # By attribute.
+            client.limit      = query.limit.to_i  if query.limit
+            client.offset     = query.offset.to_i if query.offset
 
             if order = search_order(query)
-              options.update(
-                :sort_mode => :extended,
-                :sort_by   => order
-              )
+              client.sort_mode = :extended
+              client.sort_by   = order
             end
 
-            res = @client.search(search, from, options)
-            raise res[:error] unless res[:error].nil?
+            result = client.query(search, from)
+            raise result[:error] unless result[:error].nil?
 
             DataMapper.logger.info(
-              %q{Sphinx (%.3f): search '%s' in '%s' found %d documents} % [res[:time], search, from, res[:total]]
+              %q{Sphinx (%.3f): search '%s' in '%s' found %d documents} % [result[:time], search, from, result[:total]]
             )
-            res[:matches].map{|doc| {:id => doc[:doc]}}
+            result[:matches].map{|doc| {:id => doc[:doc]}}
           end
 
 
-          ##
-          # Sphinx search query filters from attributes.
-          # @param  [DataMapper::Query]
-          # @return [Array]
-          def search_filters(query)
+          # Riddle search filters for attributes.
+          def search_filters(query) #:nodoc:
             filters = []
             query.conditions.each do |operator, attribute, value|
               next unless attribute.kind_of? Sphinx::Attribute
-              # TODO: Value cast to uint, bool, str2ordinal, float
               filters << case operator
-                when :eql, :like then Riddle::Client::Filter.new(attribute.name.to_s, filter_value(value))
-                when :not        then Riddle::Client::Filter.new(attribute.name.to_s, filter_value(value), true)
+                when :eql, :like then attribute.filter(value)
+                when :not        then attribute.filter(value, false)
                 else raise NotImplementedError.new("Sphinx: Query attributes do not support the #{operator} operator")
               end
             end
             filters
           end
 
-          ##
-          # Order by attributes.
-          #
-          # @return [String or Symbol]
-          def search_order(query)
+          # TODO: How do you tell the difference between the default query order and someone explicitly asking for
+          # sorting by the primary key? I don't think you can at the moment.
+          def search_order(query) #:nodoc:
             by = []
-            # TODO: How do you tell the difference between the default query order and someone explicitly asking for
-            # sorting by the primary key?
             query.order.each do |order|
               next unless order.property.kind_of? Sphinx::Attribute
               by << [order.property.field, order.direction].join(' ')
@@ -158,18 +165,25 @@ module DataMapper
             by.empty? ? nil : by.join(', ')
           end
 
-          # TODO: Move this to Attribute#dump.
-          # This is ninja'd straight from TS just to get things going.
-          def filter_value(value)
-            case value
-              when Range
-                value.first.is_a?(Time) ? value.first.to_i..value.last.to_i : value
-              when Array
-                value.collect { |val| val.is_a?(Time) ? val.to_i : val }
+          # Coerce +uri_or_options+ into a +Hash+ of options.
+          #
+          # ==== Parameters
+          # uri_or_options<URI, DataObject::URI, Addressable::URI, String, Hash, Pathname>::
+          #   DataMapper uri or options hash.
+          #
+          # ==== Returns
+          # Hash
+          def normalize_options(uri_or_options)
+            case uri_or_options
+              when String, Addressable::URI then DataObjects::URI.parse(uri_or_options).attributes
+              when DataObjects::URI         then uri_or_options.attributes
+              when Pathname                 then {:path => uri_or_options}
               else
-                Array(value)
+                uri_or_options[:path] ||= uri_or_options.delete(:config) || uri_or_options.delete(:database)
+                uri_or_options
             end
           end
+
       end # Adapter
     end # Sphinx
 

data/lib/dm-sphinx-adapter/attribute.rb

@@ -1,29 +1,38 @@
+require 'date'
+require 'time'
+
 module DataMapper
   module Adapters
     module Sphinx
 
-      ##
-      # Define a Sphinx attribute.
+      # Sphinx attribute definition.
+      #
+      # You must declare attributes as such if you want to use them for sorting or conditions.
       #
-      # Supports only a subset of DataMapper::Property types that can be used as Sphinx attributes.
+      # ==== Notes
+      # The following primatives will be used as sql_attr_* types. Some liberty has been taken to accommodate for as
+      # many DM primitives as possible.
       #
-      # * TrueClass                 # sql_attr_bool
-      # * String                    # sql_attr_str2ordinal
-      # * Float,                    # sql_attr_float
-      # * Integer,                  # sql_attr_uint
-      # * DateTime,                 # sql_attr_timestamp
-      # * Date,                     # sql_attr_timestamp
-      # * DataMapper::Types::Serial # sql_attr_uint
+      # TrueClass::                 sql_attr_bool
+      # String::                    sql_attr_str2ordinal
+      # DataMapper::Types::Text::   sql_attr_str2ordinal
+      # Float::                     sql_attr_float
+      # Integer::                   sql_attr_uint
+      # BigDecimal::                sql_attr_float
+      # DateTime::                  sql_attr_timestamp
+      # Date::                      sql_attr_timestamp
+      # Time::                      sql_attr_timestamp
+      # DataMapper::Types::Serial:: sql_attr_uint
       class Attribute < Property
 
         # DataMapper types supported as Sphinx attributes.
         TYPES = [
           TrueClass,                # sql_attr_bool
           String,                   # sql_attr_str2ordinal
-          # DataMapper::Types::Text,
+          DataMapper::Types::Text,  # sql_attr_str2ordinal
           Float,                    # sql_attr_float
           Integer,                  # sql_attr_uint
-          # BigDecimal,             # sql_attr_float?
+          BigDecimal,               # sql_attr_float
           DateTime,                 # sql_attr_timestamp
           Date,                     # sql_attr_timestamp
           Time,                     # sql_attr_timestamp
@@ -33,6 +42,41 @@ module DataMapper
           DataMapper::Types::Serial # sql_attr_uint
         ]
 
+        # Create a riddle client filter from a value.
+        #
+        # ==== Parameters
+        # value<Object>::
+        #   The filter value to typecast and include/exclude.
+        #
+        # inclusive<Boolean>::
+        #   Include or exclude results matching the filter value. Default: inclusive (true).
+        #
+        # ==== Returns
+        # Riddle::Client::Filter::
+        def filter(value, inclusive = true)
+          # Riddle uses exclusive = false as the default which doesn't read well IMO. Nobody says "Yes I don't want
+          # these values" you say "No I don't want these values".
+          value = typecast(value)
+          value = [value] unless value.quacks_like?([Array, Range])
+          Riddle::Client::Filter.new(field, value, !inclusive)
+        end
+
+        # Typecasts the value into a sphinx primitive. Supports ranges or arrays of values.
+        #
+        # ==== Notes
+        # Some loss of precision may occur when casting BigDecimal to Float.
+        def typecast(value)
+          if    value.kind_of?(Range)   then Range.new(typecast(value.first), typecast(value.last))
+          elsif value.kind_of?(Array)   then value.map{|v| typecast(v)}
+          elsif primitive == BigDecimal then super(value).to_f
+          elsif primitive == DateTime   then Time.parse(super(value).to_s).to_i
+          elsif primitive == Date       then Time.parse(super(value).to_s).to_i
+          elsif primitive == Time       then super(value).to_i
+          else
+            super(value) # Good luck
+          end
+        end
+
       end # Attribute
     end # Sphinx
   end # Adapters

data/lib/dm-sphinx-adapter/index.rb

@@ -1,11 +1,23 @@
 module DataMapper
   module Adapters
     module Sphinx
+
+      # Sphinx index definition.
       class Index
         include Assertions
 
+        # Options.
         attr_reader :model, :name, :options
 
+        # ==== Parameters
+        # model<DataMapper::Model>:: Your resources model.
+        # name<Symbol, String>:: The index name.
+        # options<Hash>:: Optional arguments.
+        #
+        # ==== Options
+        # :delta<Boolean>::
+        #   Delta index. Delta indexes will be searched last when multiple indexes are defined for a
+        #   resource. Default is false.
         def initialize(model, name, options = {})
           assert_kind_of 'model',   model,   Model
           assert_kind_of 'name',    name,    Symbol, String
@@ -13,9 +25,10 @@ module DataMapper
 
           @model = model
           @name  = name.to_sym
-          @delta = options.fetch(:delta, nil)
+          @delta = options.fetch(:delta, false)
         end
 
+        # Is the index a delta index.
         def delta?
           !!@delta
         end