bdimcheff-dm-sphinx-adapter 0.8.0

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

@@ -0,0 +1,83 @@
+require 'date'
+require 'time'
+
+module DataMapper
+  module Adapters
+    module Sphinx
+
+      # Sphinx attribute definition.
+      #
+      # You must declare attributes as such if you want to use them for sorting or conditions.
+      #
+      # ==== 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
+      # 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,  # 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
+          # Object,
+          # Class,
+          # DataMapper::Types::Discriminator,
+          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
+end # DataMapper

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

@@ -0,0 +1,19 @@
+module DataMapper
+  module Adapters
+    module Sphinx
+      class Collection < Array
+        attr_accessor :error, :time, :total, :words
+
+        def initialize(result)
+          # TODO: One liner that works in Ruby 1.x now #indexes is #keys?
+          @error   = result[:error]
+          @time    = result[:time]
+          @total   = result[:total]
+          @words   = result[:words]
+          super result[:matches].map{|doc| doc[:id] = doc[:doc]; doc}
+        end
+
+      end
+    end # Sphinx
+  end # Adapters
+end # DataMapper

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

@@ -0,0 +1,38 @@
+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
+          assert_kind_of 'options', options, Hash
+
+          @model = model
+          @name  = name.to_sym
+          @delta = options.fetch(:delta, false)
+        end
+
+        # Is the index a delta index.
+        def delta?
+          !!@delta
+        end
+      end # Index
+    end # Sphinx
+  end # Adapters
+end # DataMapper

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

@@ -0,0 +1,68 @@
+module DataMapper
+  module Adapters
+    module Sphinx
+
+      # Sphinx extended search query string from DataMapper query.
+      class Query
+        include Extlib::Assertions
+
+        # Initialize a new extended Sphinx query from a DataMapper::Query object.
+        #
+        # If the query has no conditions an '' empty string will be generated possibly triggering Sphinx's full scan
+        # mode.
+        #
+        # ==== See
+        # * http://www.sphinxsearch.com/doc.html#searching
+        # * http://www.sphinxsearch.com/doc.html#conf-docinfo
+        # * http://www.sphinxsearch.com/doc.html#extended-syntax
+        #
+        # ==== Raises
+        # NotImplementedError:: DataMapper operators that can't be expressed in the extended sphinx query syntax.
+        #
+        # ==== Parameters
+        # query<DataMapper::Query>:: DataMapper query object.
+        def initialize(query)
+          assert_kind_of 'query', query, DataMapper::Query
+          @query  = []
+
+          if query.conditions.empty?
+            @query << ''
+          else
+            query.conditions.each do |operator, property, value|
+              next if property.kind_of? Sphinx::Attribute # Filters are added elsewhere.
+              normalized = normalize_value(value)
+              field      = property.field(query.repository.name) unless operator == :raw
+              @query << case operator
+                when :eql, :like then '@%s "%s"'  % [field.to_s, normalized.join(' ')]
+                when :not        then '@%s -"%s"' % [field.to_s, normalized.join(' ')]
+                when :in         then '@%s (%s)'  % [field.to_s, normalized.map{|v| %{"#{v}"}}.join(' | ')]
+                when :raw        then "#{property}"
+                else raise NotImplementedError.new("Sphinx: Query fields do not support the #{operator} operator")
+              end
+            end
+          end
+        end
+
+        # ==== Returns
+        # String:: The extended sphinx query string.
+        def to_s
+          @query.join(' ')
+        end
+
+        protected
+          # Normalize and escape DataMapper query value(s) to escaped sphinx query values.
+          #
+          # ==== Parameters
+          # value<String, Array>:: The query value.
+          #
+          # ==== Returns
+          # Array:: An array of one or more query values.
+          def normalize_value(value)
+            [value].flatten.map do |v|
+              v.to_s.gsub(/[\(\)\|\-!@~"&\/]/){|char| "\\#{char}"}
+            end
+          end
+      end # Query
+    end # Sphinx
+  end # Adapters
+end # DataMapper

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

@@ -0,0 +1,120 @@
+module DataMapper
+  module Adapters
+    module Sphinx
+
+      # Declare Sphinx indexes and attributes in your resource.
+      #
+      #   model Items
+      #     include DataMapper::SphinxResource
+      #
+      #     # .. normal properties and such for :default
+      #
+      #     repository(:search) do
+      #       # Query some_index, some_index_delta in that order.
+      #       index :some_index
+      #       index :some_index_delta, :delta => true
+      #
+      #       # Sortable by some attributes.
+      #       attribute :updated_at, DateTime  # sql_attr_timestamp
+      #       attribute :age, Integer          # sql_attr_uint
+      #       attribute :deleted, Boolean      # sql_attr_bool
+      #     end
+      #   end
+      module Resource
+
+        def self.append_inclusions(*inclusions)
+          extra_inclusions.concat inclusions
+          true
+        end
+
+        def self.extra_inclusions
+          @extra_inclusions ||= []
+        end
+
+        def self.included(model) #:nodoc:
+          model.send(:include, DataMapper::Resource)
+          model.extend ClassMethods if defined?(ClassMethods)
+          extra_inclusions.each{|inclusion| model.send(:include, inclusion)}
+        end
+
+        module ClassMethods
+          def self.extended(model) #:nodoc:
+            model.instance_variable_set(:@sphinx_indexes, {})
+            model.instance_variable_set(:@sphinx_attributes, {})
+          end
+
+          # Defines a sphinx index on the resource.
+          #
+          # Indexes are naturally ordered, with delta indexes at the end of the list so that duplicate document IDs in
+          # delta indexes override your main indexes.
+          #
+          # ==== See
+          # * DataMapper::Adapters::Sphinx::Index
+          #
+          # ==== Parameters
+          # name<Symbol>:: The name of a sphinx index to search for this resource.
+          # options<Hash>:: A hash of available index options.
+          def index(name, options = {})
+            index   = Index.new(self, name, options)
+            indexes = sphinx_indexes(repository_name)
+            indexes << index
+
+            # TODO: I'm such a Ruby nub. In the meantime I've gone back to my Perl roots.
+            # This is a Schwartzian transform to sort delta indexes to the bottom and natural sort by name.
+            mapped  = indexes.map{|i| [(i.delta? ? 1 : 0), i.name, i]}
+            sorted  = mapped.sort{|a, b| a[0] <=> b[0] || a[1] <=> b[1]}
+            indexes.replace(sorted.map{|i| i[2]})
+
+            index
+          end
+
+          # List of declared sphinx indexes for this model.
+          #
+          # ==== Returns
+          # Array<DataMapper::Adapters::Sphinx::Index>
+          def sphinx_indexes(repository_name = default_repository_name)
+            @sphinx_indexes[repository_name] ||= []
+          end
+
+          # Defines a sphinx attribute on the resource.
+          #
+          # ==== See
+          # DataMapper::Adapters::Sphinx::Attribute
+          #
+          # ==== Parameters
+          # name<Symbol>:: The name of a sphinx attribute to order/restrict by for this resource.
+          # type<Class>:: The type to define this attribute as.
+          # options<Hash>:: An optional hash of attribute options.
+          def attribute(name, type, options = {})
+            # Attributes are just properties without a getter/setter in the model.
+            # This keeps DataMapper::Query happy when building queries.
+            attribute = Sphinx::Attribute.new(self, name, type, options)
+            properties(repository_name)[attribute.name] = attribute
+            attribute
+          end
+
+          # List of declared sphinx attributes for this model.
+          #
+          # ==== Returns
+          # Array<DataMapper::Adapters::Sphinx::Attribute>
+          def sphinx_attributes(repository_name = default_repository_name)
+            properties(repository_name).find_all{|p| p.kind_of? Sphinx::Attribute}
+          end
+
+          # List of properties (aka sphinx fields).
+          #
+          # This list will be the inverse of properties not declared as attributes.
+          # ==== Returns
+          def sphinx_fields(repository_name = default_repository_name)
+            properties(repository_name).reject{|p| p.kind_of? Sphinx::Attribute}
+          end
+
+        end # ClassMethods
+      end # Resource
+    end # Sphinx
+  end # Adapters
+
+  # Follow DM naming convention.
+  SphinxResource = Adapters::Sphinx::Resource
+end # DataMapper
+

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

@@ -0,0 +1,94 @@
+module DataMapper
+  module Adapters
+    module Sphinx
+      require 'builder'
+
+
+      # Sphinx xmlpipe2.
+      #
+      # Full text search data from any DM adapter without having to implement new Sphinx data sources drivers.
+      #
+      # ==== See
+      # * http://www.sphinxsearch.com/docs/current.html#xmlpipe2
+      #
+      #--
+      # TODO:
+      # * Synopsis.
+      module XmlPipe2
+        def self.included(model)
+          model.extend ClassMethods if defined?(ClassMethods)
+        end
+
+        module ClassMethods
+
+          # Write a Sphinx xmlpipe2 XML stream to $stdout.
+          #
+          # ==== Parameters
+          # source<String>::      The name of the repository to stream from.
+          # destination<String>:: The name of the repository to stream to (contains your sphinx definition).
+          # query<Hash>::         The conditions with which to find the records to stream.
+          #--
+          # TODO:
+          # * in_memory_adapter doesn't call the super constructor so there is no field_naming_convention set in
+          # DataMapper 0.9.10. Submit a patch or live with rescue and field.name clause?
+          # * Keys that aren't called .id?
+          # * Composite keys?
+          # * Method for schema and documents.
+          # * Less poking round in the internals of the :default adapter if I can?
+          # * Destination should always be a dm-sphinx-adapter adapter.
+          # * Optional schema since it overrides any schema you might define in the sphinx configuration.
+          # * Schema default values from DM property default values.
+          def xmlpipe2(source, destination = :default, query = {})
+            builder = Builder::XmlMarkup.new(:target => $stdout)
+            builder.instruct!
+            builder.sphinx(:docset, :'xmlns:sphinx' => 'sphinx') do
+
+              builder.sphinx(:schema) do
+                sphinx_fields(destination).each do |field|
+                  builder.sphinx(:field, :name => (field.field(destination) rescue field.name))
+                end
+                sphinx_attributes(destination).each do |attr|
+                  builder.sphinx(:attr, {
+                    :name => (attr.field(destination) rescue attr.name),
+                    :type => xmlpipe2_type(attr.primitive)
+                  })
+                end
+              end
+
+              all(query.merge(:repository => repository(source))).map do |resource|
+                builder.sphinx(:document, :id => resource.id) do |document|
+                  properties(destination).each do |property|
+                    # TODO: Pretty sure this isn't the correct way to get and typecast.
+                    builder.tag!((property.field(destination) rescue property.name)) do |field|
+                      field.cdata!(property.typecast(property.get(resource)))
+                    end
+                  end
+                end
+              end
+            end
+          end
+
+          private
+            def xmlpipe2_type(primitive) #:nodoc:
+              {
+                Integer                 => 'int',
+                Float                   => 'float',
+                BigDecimal              => 'float',
+                DateTime                => 'timestamp',
+                Date                    => 'timestamp',
+                Time                    => 'timestamp',
+                TrueClass               => 'bool',
+                String                  => 'str2ordinal',
+                DataMapper::Types::Text => 'str2ordinal'
+              }[primitive]
+            end
+
+        end # ClassMethods
+      end # XmlPipe2
+
+      # Include XmlPipe2 in all DM::A::SphinxResource models when you require this file.
+      Resource.append_inclusions XmlPipe2
+    end # Sphinx
+  end # Adapters
+end # DataMapper
+

data/lib/riddle.rb

@@ -0,0 +1,28 @@
+require 'socket'
+require 'timeout'
+
+require 'riddle/client'
+
+module Riddle #:nodoc:
+  class ConnectionError < StandardError #:nodoc:
+  end
+  
+  module Version #:nodoc:
+    Major   = 0
+    Minor   = 9
+    Tiny    = 8
+    # Revision number for RubyForge's sake, taken from what Sphinx
+    # outputs to the command line.
+    Rev     = 1533
+    # Release number to mark my own fixes, beyond feature parity with
+    # Sphinx itself.
+    Release = 2
+    
+    String      = [Major, Minor, Tiny].join('.')
+    GemVersion  = [Major, Minor, Tiny, Rev, Release].join('.')
+  end
+  
+  def self.escape(string)
+    string.gsub(/[\(\)\|\-!@~"&\/]/) { |char| "\\#{char}" }
+  end
+end