freelancing-god-thinking-sphinx 0.9.8 → 0.9.10

data/lib/riddle/client/filter.rb

@@ -1,44 +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| val.to_f }
-        end
-        message.append_int self.exclude? ? 1 : 0
-        
-        message.to_s
-      end
-    end
-  end
-end

data/lib/riddle/client/message.rb

@@ -1,65 +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)
-        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

@@ -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

data/lib/test.rb

@@ -1,46 +0,0 @@
-require 'thinking_sphinx'
-
-ActiveRecord::Base.establish_connection(
-  :adapter  => 'mysql',
-  :database => 'nullus_development',
-  :username => 'nullus',
-  :password => 'wossname',
-  :host     => 'localhost'
-)
-ActiveRecord::Base.logger = Logger.new(STDERR)
-
-class User < ActiveRecord::Base
-  has_many :posts, :foreign_key => "created_by"
-end
-
-class Post < ActiveRecord::Base
-  belongs_to :creator, :foreign_key => "created_by", :class_name => "User"
-  belongs_to :updater, :foreign_key => "updated_by", :class_name => "User"
-  belongs_to :topic
-end
-
-class Topic < ActiveRecord::Base
-  belongs_to :creator, :foreign_key => "created_by", :class_name => "User"
-  belongs_to :forum
-  has_many :posts
-end
-
-class Forum < ActiveRecord::Base
-  belongs_to :creator, :foreign_key => "created_by", :class_name => "User"
-  has_many :topics
-end
-
-def index
-  @index ||= ThinkingSphinx::Index.new(Topic) do
-    indexes posts.content, :as => :posts
-    indexes posts.creator.login, :as => :authors
-    
-    has :created_at
-    has :id, :as => :topic_id
-    has :forum_id
-    has posts(:id), :as => :post_ids
-    has posts.creator(:id), :as => :user_ids
-    
-    where "posts.created_at < NOW()"
-  end
-end