DrMark-thinking-sphinx 1.1.15 → 1.2.5

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,98 +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
-        
-        klass.sphinx_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
-        }
-      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.methods.should include("search_for_ids")
-  end
-  
-  it "should add search_for_ids to ActiveRecord::Base" do
-    ActiveRecord::Base.methods.should include("search")
-  end
-  
-  it "should add search_count to ActiveRecord::Base" do
-    ActiveRecord::Base.methods.should include("search_count")
-  end
-
-  it "should add search_for_id to ActiveRecord::Base" do
-    ActiveRecord::Base.methods.should include("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

data/spec/unit/thinking_sphinx/attribute_spec.rb

@@ -1,232 +0,0 @@
-require 'spec/spec_helper'
-
-describe ThinkingSphinx::Attribute do
-  before :each do
-    @index  = ThinkingSphinx::Index.new(Person)
-    @source = ThinkingSphinx::Source.new(@index)
-  end
-  
-  describe '#initialize' do
-    it 'raises if no columns are provided so that configuration errors are easier to track down' do
-      lambda {
-        ThinkingSphinx::Attribute.new(@source, [])
-      }.should raise_error(RuntimeError)
-    end
-
-    it 'raises if an element of the columns param is an integer - as happens when you use id instead of :id - so that configuration errors are easier to track down' do
-      lambda {
-        ThinkingSphinx::Attribute.new(@source, [1234])
-      }.should raise_error(RuntimeError)
-    end
-  end
-  
-  describe "unique_name method" do
-    before :each do
-      @attribute = ThinkingSphinx::Attribute.new @source, [
-        Object.stub_instance(:__stack => [], :__name => "col_name")
-      ]
-    end
-    
-    it "should use the alias if there is one" do
-      @attribute.alias = "alias"
-      @attribute.unique_name.should == "alias"
-    end
-    
-    it "should use the alias if there's multiple columns" do
-      @attribute.columns << Object.stub_instance(:__stack => [], :__name => "col_name")
-      @attribute.unique_name.should be_nil
-      
-      @attribute.alias = "alias"
-      @attribute.unique_name.should == "alias"
-    end
-    
-    it "should use the column name if there's no alias and just one column" do
-      @attribute.unique_name.should == "col_name"
-    end
-  end
-  
-  describe "column_with_prefix method" do
-    before :each do
-      @attribute = ThinkingSphinx::Attribute.new @source, [
-        ThinkingSphinx::Index::FauxColumn.new(:col_name)
-      ]
-      @attribute.columns.each { |col| @attribute.associations[col] = [] }
-      @attribute.model = Person
-      
-      @first_join   = Object.stub_instance(:aliased_table_name => "tabular")
-      @second_join  = Object.stub_instance(:aliased_table_name => "data")
-      
-      @first_assoc  = ThinkingSphinx::Association.stub_instance(
-        :join => @first_join, :has_column? => true
-      )
-      @second_assoc = ThinkingSphinx::Association.stub_instance(
-        :join => @second_join, :has_column? => true
-      )
-    end
-    
-    it "should return the column name if the column is a string" do
-      @attribute.columns = [ThinkingSphinx::Index::FauxColumn.new("string")]
-      @attribute.send(:column_with_prefix, @attribute.columns.first).should == "string"
-    end
-    
-    it "should return the column with model's table prefix if there's no associations for the column" do
-      @attribute.send(:column_with_prefix, @attribute.columns.first).should == "`people`.`col_name`"
-    end
-    
-    it "should return the column with its join table prefix if an association exists" do
-      column = @attribute.columns.first
-      @attribute.associations[column] = [@first_assoc]
-      @attribute.send(:column_with_prefix, column).should == "`tabular`.`col_name`"
-    end
-    
-    it "should return multiple columns concatenated if more than one association exists" do
-      column = @attribute.columns.first
-      @attribute.associations[column] = [@first_assoc, @second_assoc]
-      @attribute.send(:column_with_prefix, column).should == "`tabular`.`col_name`, `data`.`col_name`"
-    end
-  end
-  
-  describe "is_many? method" do
-    before :each do
-      @assoc_a = Object.stub_instance(:is_many? => true)
-      @assoc_b = Object.stub_instance(:is_many? => true)
-      @assoc_c = Object.stub_instance(:is_many? => true)
-      
-      @attribute = ThinkingSphinx::Attribute.new(
-        @source, [ThinkingSphinx::Index::FauxColumn.new(:col_name)]
-      )
-      @attribute.associations = {
-        :a => @assoc_a, :b => @assoc_b, :c => @assoc_c
-      }
-    end
-    
-    it "should return true if all associations return true to is_many?" do
-      @attribute.send(:is_many?).should be_true
-    end
-    
-    it "should return true if one association returns true to is_many?" do
-      @assoc_b.stub_method(:is_many? => false)
-      @assoc_c.stub_method(:is_many? => false)
-      
-      @attribute.send(:is_many?).should be_true
-    end
-    
-    it "should return false if all associations return false to is_many?" do
-      @assoc_a.stub_method(:is_many? => false)
-      @assoc_b.stub_method(:is_many? => false)
-      @assoc_c.stub_method(:is_many? => false)
-      
-      @attribute.send(:is_many?).should be_false
-    end
-  end
-  
-  describe "is_string? method" do
-    before :each do
-      @col_a = ThinkingSphinx::Index::FauxColumn.new("a")
-      @col_b = ThinkingSphinx::Index::FauxColumn.new("b")
-      @col_c = ThinkingSphinx::Index::FauxColumn.new("c")
-
-      @attribute = ThinkingSphinx::Attribute.new(
-        @source, [@col_a, @col_b, @col_c]
-      )
-    end
-    
-    it "should return true if all columns return true to is_string?" do
-      @attribute.send(:is_string?).should be_true
-    end
-    
-    it "should return false if one column returns true to is_string?" do
-      @col_a.send(:instance_variable_set, :@name, :a)
-      @attribute.send(:is_string?).should be_false
-    end
-    
-    it "should return false if all columns return false to is_string?" do
-      @col_a.send(:instance_variable_set, :@name, :a)
-      @col_b.send(:instance_variable_set, :@name, :b)
-      @col_c.send(:instance_variable_set, :@name, :c)
-      @attribute.send(:is_string?).should be_false
-    end
-  end
-  
-  describe "type method" do
-    before :each do
-      @column = ThinkingSphinx::Index::FauxColumn.new(:col_name)
-      @attribute = ThinkingSphinx::Attribute.new(@source, [@column])
-      @attribute.model = Person
-      @attribute.stub_method(:is_many? => false)
-    end
-    
-    it "should return :multi if is_many? is true" do
-      @attribute.stub_method(:is_many? => true)
-      @attribute.send(:type).should == :multi
-    end
-    
-    it "should return :string if there's more than one association" do
-      @attribute.associations = {:a => [:assoc], :b => [:assoc]}
-      @attribute.send(:type).should == :string
-    end
-    
-    it "should return the column type from the database if not :multi or more than one association" do
-      @column.send(:instance_variable_set, :@name, "birthday")
-      @attribute.send(:type).should == :datetime
-      
-      @attribute.send(:instance_variable_set, :@type, nil)
-      @column.send(:instance_variable_set, :@name, "first_name")
-      @attribute.send(:type).should == :string
-      
-      @attribute.send(:instance_variable_set, :@type, nil)
-      @column.send(:instance_variable_set, :@name, "id")
-      @attribute.send(:type).should == :integer
-    end
-  end
-  
-  describe "all_ints? method" do
-    it "should return true if all columns are integers" do
-      attribute = ThinkingSphinx::Attribute.new(@source,
-        [ ThinkingSphinx::Index::FauxColumn.new(:id),
-          ThinkingSphinx::Index::FauxColumn.new(:team_id) ]
-      )
-      attribute.model = Person
-      attribute.columns.each { |col| attribute.associations[col] = [] }
-      
-      attribute.send(:all_ints?).should be_true
-    end
-    
-    it "should return false if only some columns are integers" do
-      attribute = ThinkingSphinx::Attribute.new(@source,
-        [ ThinkingSphinx::Index::FauxColumn.new(:id),
-          ThinkingSphinx::Index::FauxColumn.new(:first_name) ]
-      )
-      attribute.model = Person
-      attribute.columns.each { |col| attribute.associations[col] = [] }
-      
-      attribute.send(:all_ints?).should be_false
-    end
-    
-    it "should return false if no columns are integers" do
-      attribute = ThinkingSphinx::Attribute.new(@source,
-        [ ThinkingSphinx::Index::FauxColumn.new(:first_name),
-          ThinkingSphinx::Index::FauxColumn.new(:last_name) ]
-      )
-      attribute.model = Person
-      attribute.columns.each { |col| attribute.associations[col] = [] }
-      
-      attribute.send(:all_ints?).should be_false
-    end
-  end
-  
-  describe "with custom queries" do
-    before :each do
-      index = CricketTeam.sphinx_indexes.first
-      @statement = index.sources.first.to_riddle_for_core(0, 0).sql_attr_multi.last
-    end
-    
-    it "should track the query type accordingly" do
-      @statement.should match(/uint tags from query/)
-    end
-    
-    it "should include the SQL statement" do
-      @statement.should match(/SELECT cricket_team_id, id FROM tags/)
-    end
-  end
-end

data/spec/unit/thinking_sphinx/collection_spec.rb

@@ -1,14 +0,0 @@
-require 'spec/spec_helper'
-
-describe ThinkingSphinx::Collection do
-  it "should behave like WillPaginate::Collection" do
-    ThinkingSphinx::Collection.instance_methods.should include("previous_page")
-    ThinkingSphinx::Collection.instance_methods.should include("next_page")
-    ThinkingSphinx::Collection.instance_methods.should include("current_page")
-    ThinkingSphinx::Collection.instance_methods.should include("total_pages")
-    ThinkingSphinx::Collection.instance_methods.should include("total_entries")
-    ThinkingSphinx::Collection.instance_methods.should include("offset")
-    
-    ThinkingSphinx::Collection.ancestors.should include(Array)
-  end
-end