DrMark-thinking-sphinx 0.9.9 → 1.1.6

data/vendor/delayed_job/lib/delayed/message_sending.rb

@@ -0,0 +1,7 @@
+module Delayed
+  module MessageSending
+    def send_later(method, *args)
+      Delayed::Job.enqueue Delayed::PerformableMethod.new(self, method.to_sym, args)
+    end
+  end
+end

data/vendor/delayed_job/lib/delayed/performable_method.rb

@@ -0,0 +1,55 @@
+module Delayed
+  class PerformableMethod < Struct.new(:object, :method, :args)
+    CLASS_STRING_FORMAT = /^CLASS\:([A-Z][\w\:]+)$/
+    AR_STRING_FORMAT    = /^AR\:([A-Z][\w\:]+)\:(\d+)$/
+
+    def initialize(object, method, args)
+      raise NoMethodError, "undefined method `#{method}' for #{self.inspect}" unless object.respond_to?(method)
+
+      self.object = dump(object)
+      self.args   = args.map { |a| dump(a) }
+      self.method = method.to_sym
+    end
+    
+    def display_name  
+      case self.object
+      when CLASS_STRING_FORMAT then "#{$1}.#{method}"
+      when AR_STRING_FORMAT    then "#{$1}##{method}"
+      else "Unknown##{method}"
+      end      
+    end    
+
+    def perform
+      load(object).send(method, *args.map{|a| load(a)})
+    rescue ActiveRecord::RecordNotFound
+      # We cannot do anything about objects which were deleted in the meantime
+      true
+    end
+
+    private
+
+    def load(arg)
+      case arg
+      when CLASS_STRING_FORMAT then $1.constantize
+      when AR_STRING_FORMAT    then $1.constantize.find($2)
+      else arg
+      end
+    end
+
+    def dump(arg)
+      case arg
+      when Class              then class_to_string(arg)
+      when ActiveRecord::Base then ar_to_string(arg)
+      else arg
+      end
+    end
+
+    def ar_to_string(obj)
+      "AR:#{obj.class}:#{obj.id}"
+    end
+
+    def class_to_string(obj)
+      "CLASS:#{obj.name}"
+    end
+  end
+end

data/vendor/delayed_job/lib/delayed/worker.rb

@@ -0,0 +1,54 @@
+module Delayed
+  class Worker
+    SLEEP = 5
+
+    cattr_accessor :logger
+    self.logger = if defined?(Merb::Logger)
+                    Merb.logger
+                  elsif defined?(RAILS_DEFAULT_LOGGER)
+                    RAILS_DEFAULT_LOGGER
+                  end
+
+    def initialize(options={})
+      @quiet = options[:quiet]
+      Delayed::Job.min_priority = options[:min_priority] if options.has_key?(:min_priority)
+      Delayed::Job.max_priority = options[:max_priority] if options.has_key?(:max_priority)
+    end
+
+    def start
+      say "*** Starting job worker #{Delayed::Job.worker_name}"
+
+      trap('TERM') { say 'Exiting...'; $exit = true }
+      trap('INT')  { say 'Exiting...'; $exit = true }
+
+      loop do
+        result = nil
+
+        realtime = Benchmark.realtime do
+          result = Delayed::Job.work_off
+        end
+
+        count = result.sum
+
+        break if $exit
+
+        if count.zero?
+          sleep(SLEEP)
+        else
+          say "#{count} jobs processed at %.4f j/s, %d failed ..." % [count / realtime, result.last]
+        end
+
+        break if $exit
+      end
+
+    ensure
+      Delayed::Job.clear_locks!
+    end
+
+    def say(text)
+      puts text unless @quiet
+      logger.info text if logger
+    end
+
+  end
+end

data/{lib → vendor/riddle/lib}/riddle.rb

@@ -1,9 +1,9 @@
 require 'socket'
 require 'timeout'
+
 require 'riddle/client'
-require 'riddle/client/filter'
-require 'riddle/client/message'
-require 'riddle/client/response'
+require 'riddle/configuration'
+require 'riddle/controller'
 
 module Riddle #:nodoc:
   class ConnectionError < StandardError #:nodoc:
@@ -15,12 +15,16 @@ module Riddle #:nodoc:
     Tiny    = 8
     # Revision number for RubyForge's sake, taken from what Sphinx
     # outputs to the command line.
-    Rev     = 1371
+    Rev     = 1533
     # Release number to mark my own fixes, beyond feature parity with
     # Sphinx itself.
-    Release = 0
+    Release = 4
     
     String      = [Major, Minor, Tiny].join('.')
     GemVersion  = [Major, Minor, Tiny, Rev, Release].join('.')
   end
+  
+  def self.escape(string)
+    string.gsub(/[\(\)\|\-!@~"&\/]/) { |char| "\\#{char}" }
+  end
 end

data/{lib → vendor/riddle/lib}/riddle/client.rb

@@ -1,3 +1,7 @@
+require 'riddle/client/filter'
+require 'riddle/client/message'
+require 'riddle/client/response'
+
 module Riddle
   class VersionError < StandardError;  end
   class ResponseError < StandardError; end
@@ -110,31 +114,7 @@ module Riddle
       @server = server || "localhost"
       @port   = port   || 3312
       
-      # defaults
-      @offset         = 0
-      @limit          = 20
-      @max_matches    = 1000
-      @match_mode     = :all
-      @sort_mode      = :relevance
-      @sort_by        = ''
-      @weights        = []
-      @id_range       = 0..0
-      @filters        = []
-      @group_by       = ''
-      @group_function = :day
-      @group_clause   = '@group desc'
-      @group_distinct = ''
-      @cut_off        = 0
-      @retry_count    = 0
-      @retry_delay    = 0
-      @anchor         = {}
-      # string keys are index names, integer values are weightings
-      @index_weights  = {}
-      @rank_mode      = :proximity_bm25
-      @max_query_time = 0
-      # string keys are field names, integer values are weightings
-      @field_weights  = {}
-      @timeout        = 0
+      reset
       
       @queue = []
     end
@@ -476,7 +456,7 @@ module Riddle
         header = socket.recv(8)
         status, version, length = header.unpack('n2N')
         
-        while response.length < length
+        while response.length < (length || 0)
           part = socket.recv(length - response.length)
           response << part if part
         end

data/{lib → vendor/riddle/lib}/riddle/client/filter.rb

@@ -33,7 +33,16 @@ module Riddle
           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 }
+          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
         

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

@@ -0,0 +1,33 @@
+require 'riddle/configuration/section'
+
+require 'riddle/configuration/distributed_index'
+require 'riddle/configuration/index'
+require 'riddle/configuration/indexer'
+require 'riddle/configuration/remote_index'
+require 'riddle/configuration/searchd'
+require 'riddle/configuration/source'
+require 'riddle/configuration/sql_source'
+require 'riddle/configuration/xml_source'
+
+module Riddle
+  class Configuration
+    class ConfigurationError < StandardError #:nodoc:
+    end
+    
+    attr_reader :indexes, :searchd
+    attr_accessor :indexer
+    
+    def initialize
+      @indexer = Riddle::Configuration::Indexer.new
+      @searchd = Riddle::Configuration::Searchd.new
+      @indexes = []
+    end
+    
+    def render
+      (
+        [@indexer.render, @searchd.render] +
+        @indexes.collect { |index| index.render }
+      ).join("\n")
+    end
+  end
+end

data/vendor/riddle/lib/riddle/configuration/distributed_index.rb

@@ -0,0 +1,48 @@
+module Riddle
+  class Configuration
+    class DistributedIndex < Riddle::Configuration::Section
+      self.settings = [:type, :local, :agent, :agent_connect_timeout,
+        :agent_query_timeout]
+      
+      attr_accessor :name, :local_indexes, :remote_indexes,
+        :agent_connect_timeout, :agent_query_timeout
+      
+      def initialize(name)
+        @name           = name
+        @local_indexes  = []
+        @remote_indexes = []
+      end
+      
+      def type
+        "distributed"
+      end
+      
+      def local
+        self.local_indexes
+      end
+      
+      def agent
+        agents = remote_indexes.collect { |index| index.remote }.uniq
+        agents.collect { |agent|
+          agent + ":" + remote_indexes.select { |index|
+            index.remote == agent
+          }.collect { |index| index.name }.join(",")
+        }
+      end
+      
+      def render
+        raise ConfigurationError unless valid?
+        
+        (
+          ["index #{name}", "{"] +
+          settings_body +
+          ["}", ""]
+        ).join("\n")
+      end
+      
+      def valid?
+        @local_indexes.length > 0 || @remote_indexes.length > 0
+      end
+    end
+  end
+end

data/vendor/riddle/lib/riddle/configuration/index.rb

@@ -0,0 +1,142 @@
+module Riddle
+  class Configuration
+    class Index < Riddle::Configuration::Section
+      self.settings = [:source, :path, :docinfo, :mlock, :morphology,
+        :stopwords, :wordforms, :exceptions, :min_word_len, :charset_type,
+        :charset_table, :ignore_chars, :min_prefix_len, :min_infix_len,
+        :prefix_fields, :infix_fields, :enable_star, :ngram_len, :ngram_chars,
+        :phrase_boundary, :phrase_boundary_step, :html_strip,
+        :html_index_attrs, :html_remove_elements, :preopen]
+      
+      attr_accessor :name, :parent, :sources, :path, :docinfo, :mlock,
+        :morphologies, :stopword_files, :wordform_files, :exception_files,
+        :min_word_len, :charset_type, :charset_table, :ignore_characters,
+        :min_prefix_len, :min_infix_len, :prefix_field_names,
+        :infix_field_names, :enable_star, :ngram_len, :ngram_characters,
+        :phrase_boundaries, :phrase_boundary_step, :html_strip,
+        :html_index_attrs, :html_remove_element_tags, :preopen
+      
+      def initialize(name, *sources)
+        @name                     = name
+        @sources                  = sources
+        @morphologies             = []
+        @stopword_files           = []
+        @wordform_files           = []
+        @exception_files          = []
+        @ignore_characters        = []
+        @prefix_field_names       = []
+        @infix_field_names        = []
+        @ngram_characters         = []
+        @phrase_boundaries        = []
+        @html_remove_element_tags = []
+      end
+      
+      def source
+        @sources.collect { |s| s.name }
+      end
+      
+      def morphology
+        nil_join @morphologies, ", "
+      end
+      
+      def morphology=(morphology)
+        @morphologies = nil_split morphology, /,\s?/
+      end
+      
+      def stopwords
+        nil_join @stopword_files, " "
+      end
+      
+      def stopwords=(stopwords)
+        @stopword_files = nil_split stopwords, ' '
+      end
+      
+      def wordforms
+        nil_join @wordform_files, " "
+      end
+      
+      def wordforms=(wordforms)
+        @wordform_files = nil_split wordforms, ' '
+      end
+      
+      def exceptions
+        nil_join @exception_files, " "
+      end
+      
+      def exceptions=(exceptions)
+        @exception_files = nil_split exceptions, ' '
+      end
+      
+      def ignore_chars
+        nil_join @ignore_characters, ", "
+      end
+      
+      def ignore_chars=(ignore_chars)
+        @ignore_characters = nil_split ignore_chars, /,\s?/
+      end
+      
+      def prefix_fields
+        nil_join @prefix_field_names, ", "
+      end
+      
+      def infix_fields
+        nil_join @infix_field_names, ", "
+      end
+      
+      def ngram_chars
+        nil_join @ngram_characters, ", "
+      end
+      
+      def ngram_chars=(ngram_chars)
+        @ngram_characters = nil_split ngram_chars, /,\s?/
+      end
+      
+      def phrase_boundary
+        nil_join @phrase_boundaries, ", "
+      end
+      
+      def phrase_boundary=(phrase_boundary)
+        @phrase_boundaries = nil_split phrase_boundary, /,\s?/
+      end
+      
+      def html_remove_elements
+        nil_join @html_remove_element_tags, ", "
+      end
+      
+      def html_remove_elements=(html_remove_elements)
+        @html_remove_element_tags = nil_split html_remove_elements, /,\s?/
+      end
+      
+      def render
+        raise ConfigurationError, "#{@name} #{@sources.inspect} #{@path} #{@parent}" unless valid?
+        
+        inherited_name = "#{name}"
+        inherited_name << " : #{parent}" if parent
+        (
+          @sources.collect { |s| s.render } +
+          ["index #{inherited_name}", "{"] +
+          settings_body +
+          ["}", ""]
+        ).join("\n")
+      end
+      
+      def valid?
+        (!@name.nil?) && (!( @sources.length == 0 || @path.nil? ) || !@parent.nil?)
+      end
+      
+      private
+      
+      def nil_split(string, pattern)
+        (string || "").split(pattern)
+      end
+      
+      def nil_join(array, delimiter)
+        if array.length == 0
+          nil
+        else
+          array.join(delimiter)
+        end
+      end
+    end
+  end
+end