freelancing-god-riddle 0.9.8.1371.1

data/MIT-LICENCE

@@ -0,0 +1,20 @@
+Copyright (c) 2007 Pat Allan
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README

@@ -0,0 +1,85 @@
+This client has been written to interface with Sphinx[http://sphinxsearch.com/]. It is written by
+{Pat Allan}[http://freelancing-gods.com], and has been influenced by both Dmytro Shteflyuk's Ruby
+client and the original PHP client - credit where credit's due, after all.
+
+It does not follow the same syntax as those two, though (not much point writing this otherwise) -
+opting for a more Ruby-like structure.
+
+The easiest way to install is to grab the gem from GitHub:
+
+  sudo gem install freelancing-god-riddle --source http://gems.github.com/
+
+However, if you're so inclined, you can grab sourcecode.
+
+  git clone git://github.com/freelancing-god/thinking-sphinx.git
+
+If you're looking for old versions - for older versions of Sphinx - you'll want to peruse the tagged versions in the old subversion repository
+
+  svn co http://rails-oceania.googlecode.com/svn/patallan/riddle/tags riddle-tags
+
+Please note that at the time of writing, the following versions are supported (if you get the appropriate tag):
+
+* 0.9.8-r871
+* 0.9.8-r909
+* 0.9.8-r985
+* 0.9.8-r1065
+* 0.9.8-r1112
+* 0.9.8-rc1 (gem version: 0.9.8.1198)
+* 0.9.8-rc2 (gem version: 0.9.8.1231)
+* 0.9.8 (gem version: 0.9.8.1371)
+
+To get started, just instantiate a Client object:
+
+  client = Riddle::Client.new # defaults to localhost and port 3312
+  client = Riddle::Client.new "sphinxserver.domain.tld", 3333 # custom settings
+  
+And then set the parameters to what you want, before running a query:
+
+  client.match_mode = :extended
+  client.query "Pat Allan @state Victoria"
+  
+The results from a query are similar to the other clients - but here's the details. It's a hash with
+the following keys:
+
+* :matches
+* :fields
+* :attributes
+* :attribute_names
+* :words
+* :total
+* :total_found
+* :time
+* :status
+* :warning (if appropriate)
+* :error (if appropriate)
+
+The key <tt>:matches</tt> returns an array of hashes - the actual search results. Each hash has the
+document id (<tt>:doc</tt>), the result weighting (<tt>:weight</tt>), and a hash of the attributes for
+the document (<tt>:attributes</tt>).
+
+The <tt>:fields</tt> and <tt>:attribute_names</tt> keys return list of fields and attributes for the
+documents. The key <tt>:attributes</tt> will return a hash of attribute name and type pairs, and
+<tt>:words</tt> returns a hash of hashes representing the words from the search, with the number of
+documents and hits for each, along the lines of:
+
+  results[:words]["Pat"] #=> {:docs => 12, :hits => 15}
+  
+<tt>:total</tt>, <tt>:total_found</tt> and <tt>:time</tt> return the number of matches available, the
+total number of matches (which may be greater than the maximum available), and the time in milliseconds
+that the query took to run.
+
+<tt>:status</tt> is the error code for the query - and if there was a related warning, it will be under
+the <tt>:warning</tt> key. Fatal errors will be described under <tt>:error</tt>.
+
+If you've installed the gem and wondering why there's no tests - check out the svn version. I've kept the specs out of the gem as I have a decent amount of test data in there, which really isn't needed unless you want to submit patches.
+
+== Contributors
+
+Thanks to the following people who have contributed to Riddle in some shape or form:
+
+* Andrew Aksyonoff
+* Brad Greenlee
+* Lachie Cox
+* Jeremy Seitz
+* Mark Lane
+* Xavier Noria

data/lib/riddle/client/filter.rb

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

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