thinking-sphinx 1.2.13 → 6.0.0

data/lib/thinking_sphinx/real_time/translator.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::RealTime::Translator
+  def self.call(object, column)
+    new(object, column).call
+  end
+
+  def initialize(object, column)
+    @object, @column = object, column
+  end
+
+  def call
+    return name.call(object) if name.is_a?(Proc)
+    return name   unless name.is_a?(Symbol)
+    return result unless result.is_a?(String)
+
+    result.gsub("\u0000", '').force_encoding "UTF-8"
+  end
+
+  private
+
+  attr_reader :object, :column
+
+  def name
+    @column.__name
+  end
+
+  def owner
+    stack.inject(object) { |previous, node| previous.try node }
+  end
+
+  def result
+    @result ||= owner.try name
+  end
+
+  def stack
+    @column.__stack
+  end
+end

data/lib/thinking_sphinx/real_time.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ThinkingSphinx::RealTime
+  module Callbacks
+    #
+  end
+
+  def self.callback_for(reference, path = [], &block)
+    Callbacks::RealTimeCallbacks.new reference.to_sym, path, &block
+  end
+
+  def self.populator
+    @populator ||= ThinkingSphinx::RealTime::Populator
+  end
+
+  def self.populator=(value)
+    @populator = value
+  end
+
+  def self.processor
+    @processor ||= ThinkingSphinx::RealTime::Processor
+  end
+
+  def self.processor=(value)
+    @processor = value
+  end
+end
+
+require 'thinking_sphinx/real_time/property'
+require 'thinking_sphinx/real_time/attribute'
+require 'thinking_sphinx/real_time/field'
+require 'thinking_sphinx/real_time/index'
+require 'thinking_sphinx/real_time/interpreter'
+require 'thinking_sphinx/real_time/populator'
+require 'thinking_sphinx/real_time/processor'
+require 'thinking_sphinx/real_time/transcribe_instance'
+require 'thinking_sphinx/real_time/transcriber'
+require 'thinking_sphinx/real_time/translator'
+
+require 'thinking_sphinx/real_time/callbacks/real_time_callbacks'

data/lib/thinking_sphinx/scopes.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module ThinkingSphinx::Scopes
+  extend ActiveSupport::Concern
+
+  module ClassMethods
+    def default_sphinx_scope(scope_name = nil)
+      return @default_sphinx_scope unless scope_name
+
+      @default_sphinx_scope = scope_name
+    end
+
+    def sphinx_scope(name, &block)
+      sphinx_scopes[name] = block
+    end
+
+    def sphinx_scopes
+      @sphinx_scopes ||= {}
+    end
+
+    private
+
+    def method_missing(method, *args, &block)
+      return super unless sphinx_scopes.keys.include?(method)
+
+      query, options = sphinx_scopes[method].call(*args)
+      search query, (options || {})
+    end
+
+    def respond_to_missing?(method, include_private = false)
+      super || sphinx_scopes.keys.include?(method)
+    end
+  end
+end

data/lib/thinking_sphinx/search/batch_inquirer.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Search::BatchInquirer
+  def initialize(&block)
+    @queries = []
+
+    yield self if block_given?
+  end
+
+  def append_query(query)
+    @queries << query
+  end
+
+  def results
+    @results ||= begin
+      @queries.freeze
+
+      ThinkingSphinx::Connection.take do |connection|
+        connection.query_all *@queries
+      end
+    end
+  end
+end

data/lib/thinking_sphinx/search/context.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Search::Context
+  attr_reader :search, :configuration
+
+  def initialize(search, configuration = nil)
+    @search        = search
+    @configuration = configuration || ThinkingSphinx::Configuration.instance
+    @memory        = {
+      :raw     => [],
+      :results => [],
+      :panes   => ThinkingSphinx::Configuration::Defaults::PANES.clone
+    }
+  end
+
+  def [](key)
+    @memory[key]
+  end
+
+  def []=(key, value)
+    @memory[key] = value
+  end
+
+  def marshal_dump
+    [@memory.except(:raw, :indices)]
+  end
+
+  def marshal_load(array)
+    @memory = array.first
+  end
+end

data/lib/thinking_sphinx/search/glaze.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Search::Glaze < BasicObject
+  def initialize(context, object, raw = {}, pane_classes = [])
+    @object, @raw = object, raw
+
+    @panes = pane_classes.collect { |klass|
+      klass.new context, object, @raw
+    }
+  end
+
+  def ==(object)
+    (@object == object) || super
+  end
+
+  def equal?(object)
+    @object.equal? object
+  end
+
+  def respond_to?(method, include_private = false)
+    @object.respond_to?(method, include_private) ||
+    @panes.any? { |pane| pane.respond_to?(method, include_private) }
+  end
+
+  def unglazed
+    @object
+  end
+
+  private
+
+  def method_missing(method, *args, &block)
+    pane = @panes.detect { |pane| pane.respond_to?(method) }
+    if @object.respond_to?(method) || pane.nil?
+      @object.send(method, *args, &block)
+    else
+      pane.send(method, *args, &block)
+    end
+  end
+end

data/lib/thinking_sphinx/search/merger.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Search::Merger
+  attr_reader :search
+
+  def initialize(search)
+    @search = search
+  end
+
+  def merge!(query = nil, options = {})
+    if search.populated?
+      raise ThinkingSphinx::PopulatedResultsError, 'This search request has already been made - you can no longer modify it.'
+    end
+
+    query, options = nil, query if query.is_a?(Hash)
+    @search.query  = query unless query.nil?
+
+    options.each do |key, value|
+      case key
+      when :conditions, :with, :without, :with_all, :without_all
+        @search.options[key] ||= {}
+        @search.options[key].merge! value
+      when :without_ids, :classes
+        @search.options[key] ||= []
+        @search.options[key] += value
+        @search.options[key].uniq!
+      else
+        @search.options[key] = value
+      end
+    end
+
+    @search
+  end
+end

data/lib/thinking_sphinx/search/query.rb

@@ -0,0 +1,33 @@
+# encoding: utf-8
+# frozen_string_literal: true
+
+class ThinkingSphinx::Search::Query
+  attr_reader :keywords, :conditions, :star
+
+  def initialize(keywords = '', conditions = {}, star = false)
+    @keywords, @conditions, @star = keywords, conditions, star
+  end
+
+  def to_s
+    (star_keyword(keywords || '') + ' ' + conditions.keys.collect { |key|
+       next if conditions[key].blank?
+
+      "#{expand_key key} #{star_keyword conditions[key], key}"
+    }.join(' ')).strip
+  end
+
+  private
+
+  def expand_key(key)
+    return "@#{key}" unless key.is_a?(Array)
+
+    "@(#{key.join(',')})"
+  end
+
+  def star_keyword(keyword, key = nil)
+    return keyword.to_s unless star
+    return keyword.to_s if key.to_s == 'sphinx_internal_class_name'
+
+    ThinkingSphinx::Query.wildcard keyword, star
+  end
+end

data/lib/thinking_sphinx/search/stale_ids_exception.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+class ThinkingSphinx::Search::StaleIdsException < StandardError
+  attr_reader :ids, :context
+
+  def initialize(ids, context)
+    @ids = ids
+    @context = context
+  end
+
+  def message
+    "Record IDs found by Sphinx but not by ActiveRecord : #{ids.join(', ')}\n" \
+    "https://freelancing-gods.com/thinking-sphinx/v5/common_issues.html#record-ids"
+  end
+end