shanna-dm-sphinx-adapter 0.5 → 0.6

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

@@ -2,21 +2,25 @@ module DataMapper
   module Adapters
     module Sphinx
 
-      ##
       # Sphinx extended search query string from DataMapper query.
       class Query
         include Extlib::Assertions
 
-        ##
-        # Sphinx extended search query string from DataMapper query.
+        # 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#extended-syntax
-        # @see    http://www.sphinxsearch.com/doc.html#searching
-        # @see    http://www.sphinxsearch.com/doc.html#conf-docinfo
-        # @param  [DataMapper::Query]
+        # ==== 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  = []
@@ -38,18 +42,20 @@ module DataMapper
           end
         end
 
-        ##
-        # The extended sphinx query string.
-        # @return [String]
+        # ==== 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.
-          # @param [String, Array] value The query value.
-          # @return [Array]
+          #
+          # ==== 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}"}

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

@@ -2,8 +2,7 @@ module DataMapper
   module Adapters
     module Sphinx
 
-      ##
-      # Declare Sphinx indexes in your resource.
+      # Declare Sphinx indexes and attributes in your resource.
       #
       #   model Items
       #     include DataMapper::SphinxResource
@@ -35,15 +34,17 @@ module DataMapper
             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.
           #
-          # @param [Symbol] name the name of a sphinx index to search for this resource
-          # @param [Hash(Symbol => String)] options a hash of available options
-          # @see   DataMapper::Adapters::Sphinx::Index
+          # ==== 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)
@@ -58,19 +59,23 @@ module DataMapper
             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.
           #
-          # @param [Symbol] name the name of a sphinx attribute to order/restrict by for this resource
-          # @param [Class] type the type to define this attribute as
-          # @param [Hash(Symbol => String)] options a hash of available options
-          # @see   DataMapper::Adapters::Sphinx::Attribute
+          # ==== 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.
@@ -79,8 +84,10 @@ module DataMapper
             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).grep{|p| p.kind_of? Sphinx::Attribute}
           end

data/lib/dm-sphinx-adapter.rb

@@ -1,19 +1,22 @@
 require 'rubygems'
 
 # TODO: Hide the shitload of dm-core warnings or at least try to?
-$VERBOSE = nil
-gem 'dm-core', '~> 0.9.7'
-require 'dm-core'
+old_verbose, $VERBOSE = $VERBOSE, nil
+  gem 'dm-core', '~> 0.9.7'
+  require 'dm-core'
+$VERBOSE = old_verbose
 
-# TODO: I think I might move everything to DataMapper::Sphinx::* and ignore the default naming convention.
 require 'pathname'
-dir = Pathname(__FILE__).dirname.expand_path / 'dm-sphinx-adapter'
-require dir / 'config'
-require dir / 'config_parser'
-require dir / 'client'
-require dir / 'query'
+lib = Pathname(__FILE__).dirname.expand_path
+dir = lib / 'dm-sphinx-adapter'
+
+# Bundled Riddle since the gem is very old and we don't need any of the config generation stuff.
+$:.unshift lib
+require 'riddle'
+
+# TODO: Require farms suck. Do something about it.
 require dir / 'adapter'
-require dir / 'index'
 require dir / 'attribute'
+require dir / 'index'
+require dir / 'query'
 require dir / 'resource'
-

data/lib/riddle/client/filter.rb

@@ -0,0 +1,53 @@
+module Riddle
+  class Client
+    # Used for querying Sphinx.
+    class Filter
+      attr_accessor :attribute, :values, :exclude
+      
+      # Attribute name, values (which can be an array or a range), and whether
+      # the filter should be exclusive.
+      def initialize(attribute, values, exclude=false)
+        @attribute, @values, @exclude = attribute, values, exclude
+      end
+      
+      def exclude?
+        self.exclude
+      end
+      
+      # Returns the message for this filter to send to the Sphinx service
+      def query_message
+        message = Message.new
+        
+        message.append_string self.attribute.to_s
+        case self.values
+        when Range
+          if self.values.first.is_a?(Float) && self.values.last.is_a?(Float)
+            message.append_int FilterTypes[:float_range]
+            message.append_floats self.values.first, self.values.last
+          else
+            message.append_int FilterTypes[:range]
+            message.append_ints self.values.first, self.values.last
+          end
+        when Array
+          message.append_int FilterTypes[:values]
+          message.append_int self.values.length
+          # using to_f is a hack from the php client - to workaround 32bit
+          # signed ints on x32 platforms
+          message.append_ints *self.values.collect { |val|
+            case val
+            when TrueClass
+              1.0
+            when FalseClass
+              0.0
+            else
+              val.to_f
+            end
+          }
+        end
+        message.append_int self.exclude? ? 1 : 0
+        
+        message.to_s
+      end
+    end
+  end
+end

data/lib/riddle/client/message.rb

@@ -0,0 +1,65 @@
+module Riddle
+  class Client
+    # This class takes care of the translation of ints, strings and arrays to
+    # the format required by the Sphinx service.
+    class Message
+      def initialize
+        @message = ""
+        @size_method = @message.respond_to?(:bytesize) ? :bytesize : :length
+      end
+      
+      # Append raw data (only use if you know what you're doing)
+      def append(*args)
+        return if args.length == 0
+        
+        args.each { |arg| @message << arg }
+      end
+      
+      # Append a string's length, then the string itself
+      def append_string(str)
+        @message << [str.send(@size_method)].pack('N') + str
+      end
+      
+      # Append an integer
+      def append_int(int)
+        @message << [int].pack('N')
+      end
+      
+      def append_64bit_int(int)
+        @message << [int >> 32, int & 0xFFFFFFFF].pack('NN')
+      end
+      
+      # Append a float
+      def append_float(float)
+        @message << [float].pack('f').unpack('L*').pack("N")
+      end
+      
+      # Append multiple integers
+      def append_ints(*ints)
+        ints.each { |int| append_int(int) }
+      end
+      
+      def append_64bit_ints(*ints)
+        ints.each { |int| append_64bit_int(int) }
+      end
+      
+      # Append multiple floats
+      def append_floats(*floats)
+        floats.each { |float| append_float(float) }
+      end
+      
+      # Append an array of strings - first appends the length of the array,
+      # then each item's length and value.
+      def append_array(array)
+        append_int(array.length)
+        
+        array.each { |item| append_string(item) }
+      end
+      
+      # Returns the entire message
+      def to_s
+        @message
+      end
+    end
+  end
+end

data/lib/riddle/client/response.rb

@@ -0,0 +1,84 @@
+module Riddle
+  class Client
+    # Used to interrogate responses from the Sphinx daemon. Keep in mind none
+    # of the methods here check whether the data they're grabbing are what the
+    # user expects - it just assumes the user knows what the data stream is
+    # made up of.
+    class Response
+      # Create with the data to interpret
+      def initialize(str)
+        @str = str
+        @marker = 0
+      end
+      
+      # Return the next string value in the stream
+      def next
+        len = next_int
+        result = @str[@marker, len]
+        @marker += len
+        
+        return result
+      end
+      
+      # Return the next integer value from the stream
+      def next_int
+        int = @str[@marker, 4].unpack('N*').first
+        @marker += 4
+        
+        return int
+      end
+      
+      def next_64bit_int
+        high, low = @str[@marker, 8].unpack('N*N*')[0..1]
+        @marker += 8
+        
+        return (high << 32) + low
+      end
+      
+      # Return the next float value from the stream
+      def next_float
+        float = @str[@marker, 4].unpack('N*').pack('L').unpack('f*').first
+        @marker += 4
+        
+        return float
+      end
+      
+      # Returns an array of string items
+      def next_array
+        count = next_int
+        items = []
+        for i in 0...count
+          items << self.next
+        end
+        
+        return items
+      end
+      
+      # Returns an array of int items
+      def next_int_array
+        count = next_int
+        items = []
+        for i in 0...count
+          items << self.next_int
+        end
+        
+        return items
+      end
+      
+      def next_float_array
+        count = next_int
+        items = []
+        for i in 0...count
+          items << self.next_float
+        end
+        
+        return items
+      end
+      
+      # Returns the length of the streamed data
+      def length
+        @str.length
+      end
+    end
+  end
+end