skalee-thinking-sphinx 1.3.14.1

data/vendor/after_commit/lib/after_commit/connection_adapters.rb

@@ -0,0 +1,168 @@
+module AfterCommit
+  module ConnectionAdapters
+    def self.included(base)
+      base.class_eval do
+        # The commit_db_transaction method gets called when the outermost
+        # transaction finishes and everything inside commits. We want to
+        # override it so that after this happens, any records that were saved
+        # or destroyed within this transaction now get their after_commit
+        # callback fired.
+        def commit_db_transaction_with_callback
+          increment_transaction_pointer
+          committed = false
+          begin
+            trigger_before_commit_callbacks
+            trigger_before_commit_on_create_callbacks
+            trigger_before_commit_on_update_callbacks
+            trigger_before_commit_on_destroy_callbacks
+            
+            commit_db_transaction_without_callback
+            committed = true
+            
+            trigger_after_commit_callbacks
+            trigger_after_commit_on_create_callbacks
+            trigger_after_commit_on_update_callbacks
+            trigger_after_commit_on_destroy_callbacks
+          rescue
+            rollback_db_transaction unless committed
+          ensure
+            AfterCommit.cleanup(self)
+            decrement_transaction_pointer
+          end
+        end 
+        alias_method_chain :commit_db_transaction, :callback
+
+        # In the event the transaction fails and rolls back, nothing inside
+        # should recieve the after_commit callback, but do fire the after_rollback
+        # callback for each record that failed to be committed.
+        def rollback_db_transaction_with_callback
+          begin
+            trigger_before_rollback_callbacks
+            rollback_db_transaction_without_callback
+            trigger_after_rollback_callbacks
+          ensure
+            AfterCommit.cleanup(self)
+          end
+        end
+        alias_method_chain :rollback_db_transaction, :callback
+        
+        def unique_transaction_key
+          [object_id, transaction_pointer]
+        end
+        
+        def old_transaction_key
+          [object_id, transaction_pointer - 1]
+        end
+        
+        protected
+        
+        def trigger_before_commit_callbacks
+          AfterCommit.records(self).each do |record|
+            record.send :callback, :before_commit
+          end 
+        end
+
+        def trigger_before_commit_on_create_callbacks
+          AfterCommit.created_records(self).each do |record|
+            record.send :callback, :before_commit_on_create
+          end 
+        end
+      
+        def trigger_before_commit_on_update_callbacks
+          AfterCommit.updated_records(self).each do |record|
+            record.send :callback, :before_commit_on_update
+          end 
+        end
+      
+        def trigger_before_commit_on_destroy_callbacks
+          AfterCommit.destroyed_records(self).each do |record|
+            record.send :callback, :before_commit_on_destroy
+          end 
+        end
+
+        def trigger_before_rollback_callbacks
+          AfterCommit.records(self).each do |record|
+            begin
+              record.send :callback, :before_rollback
+            rescue
+              #
+            end
+          end 
+        end
+
+        def trigger_after_commit_callbacks
+          # Trigger the after_commit callback for each of the committed
+          # records.
+          AfterCommit.records(self).each do |record|
+            begin
+              record.send :callback, :after_commit
+            rescue
+              #
+            end
+          end
+        end
+      
+        def trigger_after_commit_on_create_callbacks
+          # Trigger the after_commit_on_create callback for each of the committed
+          # records.
+          AfterCommit.created_records(self).each do |record|
+            begin
+              record.send :callback, :after_commit_on_create
+            rescue
+              #
+            end
+          end
+        end
+      
+        def trigger_after_commit_on_update_callbacks
+          # Trigger the after_commit_on_update callback for each of the committed
+          # records.
+          AfterCommit.updated_records(self).each do |record|
+            begin
+              record.send :callback, :after_commit_on_update
+            rescue
+              #
+            end
+          end
+        end
+      
+        def trigger_after_commit_on_destroy_callbacks
+          # Trigger the after_commit_on_destroy callback for each of the committed
+          # records.
+          AfterCommit.destroyed_records(self).each do |record|
+            begin
+              record.send :callback, :after_commit_on_destroy
+            rescue
+              #
+            end
+          end
+        end
+
+        def trigger_after_rollback_callbacks
+          # Trigger the after_rollback callback for each of the committed
+          # records.
+          AfterCommit.records(self).each do |record|
+            begin
+              record.send :callback, :after_rollback
+            rescue
+            end
+          end 
+        end
+        
+        def transaction_pointer
+          Thread.current[:after_commit_pointer] ||= 0
+        end
+        
+        def increment_transaction_pointer
+          Thread.current[:after_commit_pointer] ||= 0
+          Thread.current[:after_commit_pointer] += 1
+        end
+        
+        def decrement_transaction_pointer
+          Thread.current[:after_commit_pointer] ||= 0
+          Thread.current[:after_commit_pointer] -= 1
+        end
+      end 
+    end 
+  end
+end

data/vendor/after_commit/lib/after_commit/test_bypass.rb

@@ -0,0 +1,30 @@
+# Fix problems caused because tests all run in a single transaction.
+
+# The single transaction means that after_commit callback never happens in tests.  Each of these method definitions
+# overwrites the method in the after_commit plugin that stores the callback for after the commit.  In each case here
+# we simply call the callback rather than waiting for a commit that will never come.
+
+module AfterCommit::TestBypass
+  def self.included(klass)
+    klass.class_eval do
+      [:add_committed_record_on_create, :add_committed_record_on_update, :add_committed_record_on_destroy].each do |method|
+        remove_method(method)
+      end
+    end
+  end
+
+  def add_committed_record_on_create
+    callback :after_commit
+    callback :after_commit_on_create
+  end
+
+  def add_committed_record_on_update
+    callback :after_commit
+    callback :after_commit_on_update
+  end
+
+  def add_committed_record_on_destroy
+    callback :after_commit
+    callback :after_commit_on_destroy
+  end
+end

data/vendor/after_commit/lib/after_commit.rb

@@ -0,0 +1,70 @@
+module AfterCommit
+  def self.record(connection, record)
+    prepare_collection :committed_records, connection
+    add_to_collection  :committed_records, connection, record
+  end
+
+  def self.record_created(connection, record)
+    prepare_collection :committed_records_on_create, connection
+    add_to_collection  :committed_records_on_create, connection, record
+  end
+
+  def self.record_updated(connection, record)
+    prepare_collection :committed_records_on_update, connection
+    add_to_collection  :committed_records_on_update, connection, record
+  end
+
+  def self.record_destroyed(connection, record)
+    prepare_collection :committed_records_on_destroy, connection
+    add_to_collection  :committed_records_on_destroy, connection, record
+  end
+  
+  def self.records(connection)
+    collection :committed_records, connection
+  end
+
+  def self.created_records(connection)
+    collection :committed_records_on_create, connection
+  end
+
+  def self.updated_records(connection)
+    collection :committed_records_on_update, connection
+  end
+
+  def self.destroyed_records(connection)
+    collection :committed_records_on_destroy, connection
+  end
+
+  def self.cleanup(connection)
+    [
+      :committed_records,
+      :committed_records_on_create,
+      :committed_records_on_update,
+      :committed_records_on_destroy
+    ].each do |collection|
+      Thread.current[collection]                        ||= {}
+      Thread.current[collection][connection.old_transaction_key] = []
+    end
+  end
+  
+  def self.prepare_collection(collection, connection)
+    Thread.current[collection] ||= {}
+    Thread.current[collection][connection.unique_transaction_key] ||= []
+  end
+  
+  def self.add_to_collection(collection, connection, record)
+    Thread.current[collection][connection.unique_transaction_key] << record
+  end
+  
+  def self.collection(collection, connection)
+    Thread.current[collection] ||= {}
+    Thread.current[collection][connection.old_transaction_key] ||= []
+  end
+end
+
+require 'after_commit/active_record'
+require 'after_commit/connection_adapters'
+require 'after_commit/test_bypass'
+
+ActiveRecord::Base.send(:include, AfterCommit::ActiveRecord)
+ActiveRecord::Base.include_after_commit_extensions

data/vendor/riddle/lib/riddle/0.9.8.rb

@@ -0,0 +1 @@
+Riddle.loaded_version = '0.9.8'

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

@@ -0,0 +1,22 @@
+class Riddle::Client::Filter
+  #
+  
+  private
+  
+  def append_integer_range(message, range)
+    message.append_64bit_ints self.values.first, self.values.last
+  end
+  
+  def append_array(message, array)
+    message.append_64bit_ints *array.collect { |val|
+      case val
+      when TrueClass
+        1
+      when FalseClass
+        0
+      else
+        val
+      end
+    }
+  end
+end

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

@@ -0,0 +1,49 @@
+Riddle::Client::Versions[:search] = 0x116
+Riddle::Client::Versions[:update] = 0x102
+
+class Riddle::Client
+  private
+  
+  def initialise_connection
+    socket = initialise_socket
+
+    # Send version
+    socket.send [1].pack('N'), 0
+    
+    # Checking version
+    version = socket.recv(4).unpack('N*').first
+    if version < 1
+      socket.close
+      raise VersionError, "Can only connect to searchd version 1.0 or better, not version #{version}"
+    end
+    
+    socket
+  end
+  
+  def update_message(index, attributes, values_by_doc)
+    message = Message.new
+    
+    message.append_string index
+    message.append_int attributes.length
+    attributes.each_with_index do |attribute, index|
+      message.append_string attribute
+      message.append_boolean values_by_doc.values.first[index].is_a?(Array)
+    end
+    
+    message.append_int values_by_doc.length
+    values_by_doc.each do |key,values|
+      message.append_64bit_int key # document ID
+      values.each do |value|
+        case value
+        when Array
+          message.append_int value.length
+          message.append_ints *value
+        else
+          message.append_int value
+        end
+      end
+    end
+    
+    message.to_s
+  end
+end

data/vendor/riddle/lib/riddle/0.9.9/configuration/searchd.rb

@@ -0,0 +1,28 @@
+module Riddle
+  class Configuration
+    class Searchd
+      def valid?
+        set_listen
+        clear_deprecated
+        
+        !( @listen.nil? || @pid_file.nil? )
+      end
+      
+      private
+      
+      def set_listen
+        return unless @listen.nil?
+        
+        @listen = @port.to_s if @port && @address.nil?
+        @listen = "#{@address}:#{@port}" if @address && @port
+      end
+      
+      def clear_deprecated
+        return if @listen.nil?
+        
+        @address  = nil
+        @port     = nil
+      end
+    end
+  end
+end

data/vendor/riddle/lib/riddle/0.9.9.rb

@@ -0,0 +1,7 @@
+Riddle.loaded_version = '0.9.9'
+
+require 'riddle/0.9.9/client'
+require 'riddle/0.9.9/client/filter'
+require 'riddle/0.9.9/configuration/searchd'
+
+Riddle.escape_pattern = /[\(\)\|\-!@~"&\/\\\^\$=]/

data/vendor/riddle/lib/riddle/auto_version.rb

@@ -0,0 +1,11 @@
+class Riddle::AutoVersion
+  def self.configure
+    controller = Riddle::Controller.new nil, ''
+    version    = controller.sphinx_version
+    
+    case version
+    when '0.9.8', '0.9.9'
+      require "riddle/#{version}"
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+module Riddle
+  class Client
+    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]
+            append_integer_range message, self.values
+          end
+        when Array
+          message.append_int FilterTypes[:values]
+          message.append_int self.values.length
+          append_array message, self.values
+        end
+        message.append_int self.exclude? ? 1 : 0
+    
+        message.to_s
+      end
+  
+      private
+  
+      def append_integer_range(message, range)
+        message.append_ints self.values.first, self.values.last
+      end
+  
+      # Using to_f is a hack from the PHP client - to workaround 32bit signed
+      # ints on x32 platforms
+      def append_array(message, array)
+        message.append_ints *array.collect { |val|
+          case val
+          when TrueClass
+            1.0
+          when FalseClass
+            0.0
+          else
+            val.to_f
+          end
+        }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+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
+      
+      def append_boolean(bool)
+        append_int(bool ? 1 : 0)
+      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

@@ -0,0 +1,94 @@
+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
+      
+      def next_64bit_int_array
+        count = next_int
+        items = []
+        for i in 0...count
+          items << self.next_64bit_int
+        end
+        
+        return items
+      end
+      
+      # Returns the length of the streamed data
+      def length
+        @str.length
+      end
+    end
+  end
+end