thinking-sphinx 1.2.13 → 6.0.0

data/vendor/riddle/lib/riddle/client/filter.rb

@@ -1,53 +0,0 @@
-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/vendor/riddle/lib/riddle/client/message.rb

@@ -1,66 +0,0 @@
-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)
-        args.each { |arg| @message << arg }
-      end
-      
-      # Append a string's length, then the string itself
-      def append_string(str)
-        string = str.respond_to?(:force_encoding) ?
-          str.dup.force_encoding('ASCII-8BIT') : str
-        
-        @message << [string.send(@size_method)].pack('N') + string
-      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/vendor/riddle/lib/riddle/client/response.rb

@@ -1,84 +0,0 @@
-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