ebeigarts-thinking-sphinx 1.1.22 → 1.2.10

data/lib/thinking_sphinx/active_record/search.rb

@@ -1,57 +0,0 @@
-module ThinkingSphinx
-  module ActiveRecord
-    # This module covers the specific model searches - but the syntax is
-    # exactly the same as the core Search class - so use that as your refence
-    # point.
-    # 
-    module Search
-      def self.included(base)
-        base.class_eval do
-          class << self
-            # Searches for results that match the parameters provided. Will only
-            # return the ids for the matching objects. See
-            # ThinkingSphinx::Search#search for syntax examples.
-            #
-            def search_for_ids(*args)
-              options = args.extract_options!
-              options[:class] = self
-              args << options
-              ThinkingSphinx::Search.search_for_ids(*args)
-            end
-
-            # Searches for results limited to a single model. See
-            # ThinkingSphinx::Search#search for syntax examples.
-            #
-            def search(*args)
-              options = args.extract_options!
-              options[:class] = self
-              args << options
-              ThinkingSphinx::Search.search(*args)
-            end
-
-            def search_count(*args)
-              options = args.extract_options!
-              options[:class] = self
-              args << options
-              ThinkingSphinx::Search.count(*args)
-            end
-
-            def search_for_id(*args)
-              options = args.extract_options!
-              options[:class] = self
-              args << options
-              ThinkingSphinx::Search.search_for_id(*args)
-            end
-            
-            def facets(*args)
-              options = args.extract_options!
-              options[:class] = self
-              args << options
-              ThinkingSphinx::Search.facets(*args)
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/thinking_sphinx/collection.rb

@@ -1,148 +0,0 @@
-module ThinkingSphinx
-  class Collection < ::Array
-    attr_reader :total_entries, :total_pages, :current_page, :per_page
-    attr_accessor :results
-
-    # Compatibility with older versions of will_paginate
-    alias_method :page_count, :total_pages
-    
-    def initialize(page, per_page, entries, total_entries)
-      @current_page, @per_page, @total_entries = page, per_page, total_entries
-      
-      @total_pages = (entries / @per_page.to_f).ceil
-    end
-    
-    def self.ids_from_results(results, page, limit, options)
-      collection = self.new(page, limit,
-        results[:total] || 0, results[:total_found] || 0
-      )
-      collection.results = results
-      collection.replace results[:matches].collect { |match|
-        match[:attributes]["sphinx_internal_id"]
-      }
-      return collection
-    end
-    
-    def self.create_from_results(results, page, limit, options)
-      collection = self.new(page, limit,
-        results[:total] || 0, results[:total_found] || 0
-      )
-      collection.results = results
-      collection.replace instances_from_matches(results[:matches], options)
-      return collection
-    end
-    
-    def self.instances_from_matches(matches, options = {})
-      if klass = options[:class]
-        instances_from_class klass, matches, options
-      else
-        instances_from_classes matches, options
-      end
-    end
-    
-    def self.instances_from_class(klass, matches, options = {})
-      index_options = klass.sphinx_index_options
-
-      ids = matches.collect { |match| match[:attributes]["sphinx_internal_id"] }
-      instances = ids.length > 0 ? klass.find(
-        :all,
-        :joins      => options[:joins],
-        :conditions => {klass.primary_key.to_sym => ids},
-        :include    => (options[:include] || index_options[:include]),
-        :select     => (options[:select]  || index_options[:select]),
-        :order      => (options[:sql_order] || index_options[:sql_order])
-      ) : []
-
-      # Raise an exception if we find records in Sphinx but not in the DB, so
-      # the search method can retry without them. See 
-      # ThinkingSphinx::Search.retry_search_on_stale_index.
-      if options[:raise_on_stale] && instances.length < ids.length
-        stale_ids = ids - instances.map {|i| i.id }
-        raise StaleIdsException, stale_ids
-      end
-
-      # if the user has specified an SQL order, return the collection
-      # without rearranging it into the Sphinx order
-      return instances if options[:sql_order]
-
-      ids.collect { |obj_id|
-        instances.detect { |obj| obj.id == obj_id }
-      }
-    end
-    
-    # Group results by class and call #find(:all) once for each group to reduce
-    # the number of #find's in multi-model searches.
-    # 
-    def self.instances_from_classes(matches, options = {})
-      groups = matches.group_by { |match| match[:attributes]["class_crc"] }
-      groups.each do |crc, group|
-        group.replace(
-          instances_from_class(class_from_crc(crc), group, options)
-        )
-      end
-      
-      matches.collect do |match|
-        groups.detect { |crc, group|
-          crc == match[:attributes]["class_crc"]
-        }[1].detect { |obj|
-          obj.id == match[:attributes]["sphinx_internal_id"]
-        }
-      end
-    end
-    
-    def self.class_from_crc(crc)
-      @@models_by_crc ||= ThinkingSphinx.indexed_models.inject({}) do |hash, model|
-        hash[model.constantize.to_crc32] = model
-        model.constantize.subclasses.each { |subclass|
-          hash[subclass.to_crc32] = subclass.name
-        }
-        hash
-      end
-      @@models_by_crc[crc].constantize
-    end
-    
-    def previous_page
-      current_page > 1 ? (current_page - 1) : nil
-    end
-    
-    def next_page
-      current_page < total_pages ? (current_page + 1): nil
-    end
-    
-    def offset
-      (current_page - 1) * @per_page
-    end
-    
-    def method_missing(method, *args, &block)
-      super unless method.to_s[/^each_with_.*/]
-      
-      each_with_attribute method.to_s.gsub(/^each_with_/, ''), &block
-    end
-    
-    def each_with_groupby_and_count(&block)
-      results[:matches].each_with_index do |match, index|
-        yield self[index], match[:attributes]["@groupby"], match[:attributes]["@count"]
-      end
-    end
-    
-    def each_with_attribute(attribute, &block)
-      results[:matches].each_with_index do |match, index|
-        yield self[index], (match[:attributes][attribute] || match[:attributes]["@#{attribute}"])
-      end
-    end
-    
-    def each_with_weighting(&block)
-      results[:matches].each_with_index do |match, index|
-        yield self[index], match[:weight]
-      end
-    end
-    
-    def inject_with_groupby_and_count(initial = nil, &block)
-      index = -1
-      results[:matches].inject(initial) do |memo, match|
-        index += 1
-        yield memo, self[index], match[:attributes]["@groupby"], match[:attributes]["@count"]
-      end
-    end
-  end
-end

data/lib/thinking_sphinx/facet_collection.rb

@@ -1,59 +0,0 @@
-module ThinkingSphinx
-  class FacetCollection < Hash
-    attr_accessor :arguments
-    
-    def initialize(arguments)
-      @arguments    = arguments.clone
-      @facet_names  = []
-    end
-    
-    def add_from_results(facet, results)
-      name = ThinkingSphinx::Facet.name_for(facet)
-      
-      self[name]  ||= {}
-      @facet_names << name
-      
-      return if results.empty?
-      
-      facet = facet_from_object(results.first, facet) if facet.is_a?(String)
-      
-      results.each_with_groupby_and_count { |result, group, count|
-        facet_value = facet.value(result, group)
-        
-        self[name][facet_value] ||= 0
-        self[name][facet_value]  += count
-      }
-    end
-    
-    def for(hash = {})
-      arguments        = @arguments.clone
-      options          = arguments.extract_options!
-      options[:with] ||= {}
-      
-      hash.each do |key, value|
-        attrib = ThinkingSphinx::Facet.attribute_name_from_value(key, value)
-        options[:with][attrib] = underlying_value key, value
-      end
-      
-      arguments << options
-      ThinkingSphinx::Search.search *arguments
-    end
-    
-    private
-    
-    def underlying_value(key, value)
-      case value
-      when Array
-        value.collect { |item| underlying_value(key, item) }
-      when String
-        value.to_crc32
-      else
-        value
-      end
-    end
-    
-    def facet_from_object(object, name)
-      object.sphinx_facets.detect { |facet| facet.attribute_name == name }
-    end
-  end
-end

data/lib/thinking_sphinx/search/facets.rb

@@ -1,104 +0,0 @@
-module ThinkingSphinx
-  class Search
-    module Facets
-      # Model.facets *args
-      # ThinkingSphinx::Search.facets *args
-      # ThinkingSphinx::Search.facets *args, :all_attributes  => true
-      # ThinkingSphinx::Search.facets *args, :class_facet     => false
-      # 
-      def facets(*args)
-        options = args.extract_options!
-        
-        if options[:class]
-          facets_for_model options[:class], args, options
-        else
-          facets_for_all_models args, options
-        end
-      end
-      
-      private
-      
-      def facets_for_model(klass, args, options)
-        hash    = ThinkingSphinx::FacetCollection.new args + [options]
-        options = options.clone.merge! facet_query_options
-        
-        facets  = klass.sphinx_facets
-        facets  = Array(options.delete(:facets)).collect { |name|
-          klass.sphinx_facets.detect { |facet| facet.name.to_s == name.to_s }
-        }.compact if options[:facets]
-        
-        facets.inject(hash) do |hash, facet|
-          unless facet.name == :class && !options[:class_facet]
-            options[:group_by]    = facet.attribute_name
-            hash.add_from_results facet, search(*(args + [options]))
-          end
-          
-          hash
-        end
-      end
-      
-      def facets_for_all_models(args, options)
-        options = GlobalFacetOptions.merge(options)
-        hash    = ThinkingSphinx::FacetCollection.new args + [options]
-        options = options.merge! facet_query_options
-        
-        facet_names(options).inject(hash) do |hash, name|
-          options[:group_by] = name
-          hash.add_from_results name, search(*(args + [options]))
-          hash
-        end
-      end
-      
-      def facet_query_options
-        config = ThinkingSphinx::Configuration.instance
-        max    = config.configuration.searchd.max_matches || 1000
-        
-        {
-          :group_function => :attr,
-          :limit          => max,
-          :max_matches    => max,
-          :page           => 1
-        }
-      end
-      
-      def facet_classes(options)
-        options[:classes] || ThinkingSphinx.indexed_models.collect { |model|
-          model.constantize
-        }
-      end
-      
-      def facet_names(options)
-        classes = facet_classes(options)
-        names   = options[:all_attributes] ?
-          facet_names_for_all_classes(classes) :
-          facet_names_common_to_all_classes(classes)
-        
-        names.delete "class_crc" unless options[:class_facet]
-        names
-      end
-      
-      def facet_names_for_all_classes(classes)
-        all_facets = classes.collect { |klass| klass.sphinx_facets }.flatten
-        
-        all_facets.group_by { |facet|
-          facet.name
-        }.collect { |name, facets|
-          if facets.collect { |facet| facet.type }.uniq.length > 1
-            raise "Facet #{name} exists in more than one model with different types"
-          end
-          facets.first.attribute_name
-        }
-      end
-      
-      def facet_names_common_to_all_classes(classes)
-        facet_names_for_all_classes(classes).select { |name|
-          classes.all? { |klass|
-            klass.sphinx_facets.detect { |facet|
-              facet.attribute_name == name
-            }
-          }
-        }
-      end
-    end
-  end
-end

data/spec/unit/thinking_sphinx/active_record/search_spec.rb

@@ -1,107 +0,0 @@
-require 'spec/spec_helper'
-
-describe "ThinkingSphinx::ActiveRecord::Search" do
-  it "should add search_for_ids to ActiveRecord::Base" do
-    ActiveRecord::Base.should respond_to("search_for_ids")
-  end
-  
-  it "should add search_for_ids to ActiveRecord::Base" do
-    ActiveRecord::Base.should respond_to("search")
-  end
-  
-  it "should add search_count to ActiveRecord::Base" do
-    ActiveRecord::Base.should respond_to("search_count")
-  end
-
-  it "should add search_for_id to ActiveRecord::Base" do
-    ActiveRecord::Base.should respond_to("search_for_id")
-  end
-  
-  describe "search_for_ids method" do
-    before :each do
-      ThinkingSphinx::Search.stub_method(:search_for_ids => true)
-    end
-    
-    it "should call ThinkingSphinx::Search#search_for_ids with the class option set" do
-      Person.search_for_ids("search")
-      
-      ThinkingSphinx::Search.should have_received(:search_for_ids).with(
-        "search", :class => Person
-      )
-    end
-    
-    it "should override the class option" do
-      Person.search_for_ids("search", :class => Friendship)
-      
-      ThinkingSphinx::Search.should have_received(:search_for_ids).with(
-        "search", :class => Person
-      )
-    end
-  end
-  
-  describe "search method" do
-    before :each do
-      ThinkingSphinx::Search.stub_method(:search => true)
-    end
-    
-    it "should call ThinkingSphinx::Search#search with the class option set" do
-      Person.search("search")
-      
-      ThinkingSphinx::Search.should have_received(:search).with(
-        "search", :class => Person
-      )
-    end
-    
-    it "should override the class option" do
-      Person.search("search", :class => Friendship)
-      
-      ThinkingSphinx::Search.should have_received(:search).with(
-        "search", :class => Person
-      )
-    end
-  end
-  
-  describe "search_for_id method" do
-    before :each do
-      ThinkingSphinx::Search.stub_method(:search_for_id => true)
-    end
-    
-    it "should call ThinkingSphinx::Search#search with the class option set" do
-      Person.search_for_id(10)
-      
-      ThinkingSphinx::Search.should have_received(:search_for_id).with(
-        10, :class => Person
-      )
-    end
-    
-    it "should override the class option" do
-      Person.search_for_id(10, :class => Friendship)
-      
-      ThinkingSphinx::Search.should have_received(:search_for_id).with(
-        10, :class => Person
-      )
-    end
-  end
-
-  describe "search_count method" do
-    before :each do
-      ThinkingSphinx::Search.stub_method(:count => true)
-    end
-
-    it "should call ThinkingSphinx::Search#search with the class option set" do
-      Person.search_count("search")
-
-      ThinkingSphinx::Search.should have_received(:count).with(
-        "search", :class => Person
-      )
-    end
-
-    it "should override the class option" do
-      Person.search_count("search", :class => Friendship)
-
-      ThinkingSphinx::Search.should have_received(:count).with(
-        "search", :class => Person
-      )
-    end
-  end
-end