thinking-sphinx 1.5.0 → 2.0.0.rc1

data/features/field_sorting.feature

@@ -1,18 +0,0 @@
-Feature: Field Sorting
-  In order to sort by strings
-  As a developer
-  I want to enable sorting by existing fields
-  
-  Background:
-    Given Sphinx is running
-    And I am searching on people
-    
-  Scenario: Searching with ordering on a sortable field
-    When I order by first_name
-    Then I should get 20 results
-    And the first_name of each result should indicate order
-  
-  Scenario: Sort on a case insensitive sortable field
-    When I order by last_name
-    Then the first result's "last_name" should be "abbott"
-  

data/features/thinking_sphinx/db/.gitignore

@@ -1 +0,0 @@
-database.yml

data/features/thinking_sphinx/db/fixtures/post_keywords.txt

@@ -1 +0,0 @@
-foo bar baz

data/features/thinking_sphinx/models/andrew.rb

@@ -1,17 +0,0 @@
-require "#{File.dirname(__FILE__)}/person"
-
-class Andrew < ActiveRecord::Base
-  set_table_name 'people'
-  
-  define_index do
-    indexes first_name, last_name, street_address
-  end
-  
-  sphinx_scope(:locked_first_name) {
-    {:conditions => {:first_name => 'Andrew'}}
-  }
-  sphinx_scope(:locked_last_name) {
-    {:conditions => {:last_name => 'Byrne'}}
-  }
-  default_sphinx_scope :locked_first_name
-end

data/lib/thinking-sphinx.rb

@@ -1 +0,0 @@
-require 'thinking_sphinx'

data/lib/thinking_sphinx/active_record/has_many_association_with_scopes.rb

@@ -1,21 +0,0 @@
-module ThinkingSphinx
-  module ActiveRecord
-    module HasManyAssociationWithScopes
-      def method_missing(method, *args, &block)
-        if responds_to_scope(method)
-          @reflection.klass.
-            search(:with => default_filter).
-            send(method, *args, &block)
-        else
-          super
-        end
-      end
-      
-      private
-      def responds_to_scope(scope)
-        @reflection.klass.respond_to?(:sphinx_scopes)   &&
-        @reflection.klass.sphinx_scopes.include?(scope)
-      end
-    end
-  end
-end

data/lib/thinking_sphinx/bundled_search.rb

@@ -1,40 +0,0 @@
-module ThinkingSphinx
-  class BundledSearch
-    def initialize
-      @searches = []
-    end
-
-    def search(*args)
-      @searches << ThinkingSphinx.search(*args)
-    end
-
-    def search_for_ids(*args)
-      @searches << ThinkingSphinx.search_for_ids(*args)
-    end
-
-    def searches
-      populate
-      @searches
-    end
-
-    private
-
-    def populated?
-      @populated
-    end
-
-    def populate
-      return if populated?
-
-      @populated = true
-
-      ThinkingSphinx::Connection.take do |client|
-        @searches.each { |search| search.append_to client }
-
-        client.run.each_with_index do |results, index|
-          searches[index].populate_from_queue results
-        end
-      end
-    end
-  end
-end

data/lib/thinking_sphinx/connection.rb

@@ -1,71 +0,0 @@
-class ThinkingSphinx::Connection
-  def self.pool
-    @pool ||= Innertube::Pool.new(
-      Proc.new { ThinkingSphinx::Connection.new },
-      Proc.new { |connection| connection.close }
-    )
-  end
-
-  def self.take
-    retries  = 0
-    original = nil
-    begin
-      pool.take do |connection|
-        connection.reset
-        begin
-          yield connection
-        rescue Riddle::ConnectionError, Riddle::ResponseError, SystemCallError => error
-          original = error
-          raise Innertube::Pool::BadResource
-        end
-      end
-    rescue Innertube::Pool::BadResource
-      retries += 1
-      retry if retries < 3
-      raise original
-    end
-  end
-
-  def initialize
-    client.open
-  end
-
-  def client
-    @client ||= begin
-      client = Riddle::Client.new shuffled_addresses, configuration.port,
-        client_key
-      client.max_matches = _max_matches
-      client.timeout     = configuration.timeout || 0
-      client
-    end
-  end
-
-  private
-
-  def client_key
-    configuration.configuration.searchd.client_key
-  end
-
-  def configuration
-    ThinkingSphinx::Configuration.instance
-  end
-
-  def _max_matches
-    configuration.configuration.searchd.max_matches || 1000
-  end
-
-  def method_missing(method, *arguments, &block)
-    client.send method, *arguments, &block
-  end
-
-  def shuffled_addresses
-    return configuration.address unless configuration.shuffle
-
-    addresses = Array(configuration.address)
-    if addresses.respond_to?(:shuffle)
-      addresses.shuffle
-    else
-      address.sort_by { rand }
-    end
-  end
-end

data/lib/thinking_sphinx/deltas/delete_job.rb

@@ -1,16 +0,0 @@
-class ThinkingSphinx::Deltas::DeleteJob
-  def initialize(indices, document_id)
-    @indices, @document_id = indices, document_id
-  end
-
-  def perform
-    ThinkingSphinx::Connection.take do |client|
-      @indices.each do |index|
-        client.update(index, ['sphinx_deleted'], {@document_id => [1]})
-      end
-    end
-  rescue Riddle::ConnectionError, Riddle::ResponseError,
-    ThinkingSphinx::SphinxError, Errno::ETIMEDOUT, Timeout::Error
-    # Not the end of the world if Sphinx isn't running.
-  end
-end

data/lib/thinking_sphinx/deltas/index_job.rb

@@ -1,17 +0,0 @@
-class ThinkingSphinx::Deltas::IndexJob
-  def initialize(indices)
-    @indices = indices
-    @indices << {:verbose => !ThinkingSphinx.suppress_delta_output?}
-  end
-
-  def perform
-    ThinkingSphinx::Configuration.instance.controller.index *@indices
-    ThinkingSphinx::Connection.pool.clear
-
-    true
-  end
-
-  def configuration
-    ThinkingSphinx::Configuration.instance
-  end
-end

data/lib/thinking_sphinx/rails_additions.rb

@@ -1,181 +0,0 @@
-module ThinkingSphinx
-  module HashExcept
-    # Returns a new hash without the given keys.
-    def except(*keys)
-      rejected = Set.new(respond_to?(:convert_key) ? keys.map { |key| convert_key(key) } : keys)
-      reject { |key,| rejected.include?(key) }
-    end
-
-    # Replaces the hash without only the given keys.
-    def except!(*keys)
-      replace(except(*keys))
-    end
-  end
-end
-
-Hash.send(
-  :include, ThinkingSphinx::HashExcept
-) unless Hash.instance_methods.include?("except")
-
-module ThinkingSphinx
-  module ArrayExtractOptions
-    def extract_options!
-      last.is_a?(::Hash) ? pop : {}
-    end
-  end
-end
-
-Array.send(
-  :include, ThinkingSphinx::ArrayExtractOptions
-) unless Array.instance_methods.include?("extract_options!")
-
-module ThinkingSphinx
-  module AbstractQuotedTableName
-    def quote_table_name(name)
-      quote_column_name(name)
-    end
-  end
-end
-
-ActiveRecord::ConnectionAdapters::AbstractAdapter.send(
-  :include, ThinkingSphinx::AbstractQuotedTableName
-) unless ActiveRecord::ConnectionAdapters::AbstractAdapter.instance_methods.include?("quote_table_name")
-
-module ThinkingSphinx
-  module MysqlQuotedTableName
-    def quote_table_name(name) #:nodoc:
-      quote_column_name(name).gsub('.', '`.`')
-    end
-  end
-end
-
-if ActiveRecord::ConnectionAdapters.constants.include?("MysqlAdapter") or ActiveRecord::Base.respond_to?(:jdbcmysql_connection)
-  adapter = ActiveRecord::ConnectionAdapters.const_get(
-    defined?(JRUBY_VERSION) ? :JdbcAdapter : :MysqlAdapter
-  )
-  unless adapter.instance_methods.include?("quote_table_name")
-    adapter.send(:include, ThinkingSphinx::MysqlQuotedTableName)
-  end
-end
-
-module ThinkingSphinx
-  module ActiveRecordQuotedName
-    def quoted_table_name
-      self.connection.quote_table_name(self.table_name)
-    end 
-  end
-end
-
-ActiveRecord::Base.extend(
-  ThinkingSphinx::ActiveRecordQuotedName
-) unless ActiveRecord::Base.respond_to?("quoted_table_name")
-
-module ThinkingSphinx
-  module ActiveRecordStoreFullSTIClass
-    def store_full_sti_class
-      false
-    end
-  end
-end
-
-ActiveRecord::Base.extend(
-  ThinkingSphinx::ActiveRecordStoreFullSTIClass
-) unless ActiveRecord::Base.respond_to?(:store_full_sti_class)
-
-module ThinkingSphinx
-  module ClassAttributeMethods
-    def cattr_reader(*syms)
-      syms.flatten.each do |sym|
-        next if sym.is_a?(Hash)
-        class_eval(<<-EOS, __FILE__, __LINE__)
-          unless defined? @@#{sym}
-            @@#{sym} = nil
-          end
-
-          def self.#{sym}
-            @@#{sym}
-          end
-
-          def #{sym}
-            @@#{sym}
-          end
-        EOS
-      end
-    end
-
-    def cattr_writer(*syms)
-      options = syms.extract_options!
-      syms.flatten.each do |sym|
-        class_eval(<<-EOS, __FILE__, __LINE__)
-          unless defined? @@#{sym}
-            @@#{sym} = nil
-          end
-
-          def self.#{sym}=(obj)
-            @@#{sym} = obj
-          end
-
-          #{"
-          def #{sym}=(obj)
-            @@#{sym} = obj
-          end
-          " unless options[:instance_writer] == false }
-        EOS
-      end
-    end
-
-    def cattr_accessor(*syms)
-      cattr_reader(*syms)
-      cattr_writer(*syms)
-    end
-  end
-end
-
-Class.extend(
-  ThinkingSphinx::ClassAttributeMethods
-) unless Class.respond_to?(:cattr_reader)
-
-module ThinkingSphinx
-  module SingletonClass
-    def singleton_class
-      class << self
-        self
-      end
-    end
-  end
-end
-
-unless Object.new.respond_to?(:singleton_class)
-  Object.send(:include, ThinkingSphinx::SingletonClass)
-end
-
-module ThinkingSphinx
-  module ObjectTry
-    def try(*a, &b)
-      if a.empty? && block_given?
-        yield self
-      else
-        __send__(*a, &b)
-      end
-    end
-  end
-
-  module NilClassTry
-    def try(*args)
-      nil
-    end
-  end
-end
-
-Object.send(:include, ThinkingSphinx::ObjectTry) unless Object.new.respond_to?(:try)
-NilClass.send(:include, ThinkingSphinx::NilClassTry) unless nil.respond_to?(:try)
-
-module ThinkingSphinx
-  module EnumerableOne
-    def one?(&block)
-      select(&block).size == 1
-    end
-  end
-end
-
-Enumerable.send(:include, ThinkingSphinx::EnumerableOne) unless [].respond_to?(:one?)

data/spec/fixtures/data.sql

@@ -1,32 +0,0 @@
-insert into `people` (gender, first_name, middle_initial, last_name, street_address, city, state, postcode, email, birthday, team_id, team_type) values('female','Ellie','K','Ford','38 Mills Street','Eagle Farm Bc','QLD','4009','Ellie.K.Ford@mailinator.com','1970/1/23 00:00:00', 3, 'CricketTeam');
-insert into `people` (gender, first_name, middle_initial, last_name, street_address, city, state, postcode, email, birthday, team_id, team_type) values('female','Aaliyah','E','Allen','71 Murphy Street','Wyola West','WA','6407','Aaliyah.E.Allen@dodgit.com','1980/3/23 00:00:00', 3, 'CricketTeam');
-insert into `people` (gender, first_name, middle_initial, last_name, street_address, city, state, postcode, email, birthday, team_id, team_type) values('male','Callum','C','Miah','89 Dalgarno Street','Bullawa Creek','NSW','2390','Callum.C.Miah@trashymail.com','1973/3/25 00:00:00', 3, 'CricketTeam');
-insert into `people` (gender, first_name, middle_initial, last_name, street_address, city, state, postcode, email, birthday, team_id, team_type) values('male','Finley','L','Buckley','18 Queen Street','Manly Vale','NSW','2093','Finley.L.Buckley@spambob.com','1962/11/20 00:00:00', 3, 'CricketTeam');
-insert into `people` (gender, first_name, middle_initial, last_name, street_address, city, state, postcode, email, birthday, team_id, team_type) values('female','Poppy','A','Hilton','36 Nerrigundah Drive','Nyora','VIC','3987','Poppy.A.Hilton@dodgit.com','1972/10/30 00:00:00', 3, 'CricketTeam');
-insert into `people` (gender, first_name, middle_initial, last_name, street_address, city, state, postcode, email, birthday, team_id, team_type) values('female','Eloise','Z','Kennedy','18 Mt Berryman Road','Lilydale','QLD','4344','Eloise.Z.Kennedy@spambob.com','1973/9/28 00:00:00', 3, 'CricketTeam');
-insert into `people` (gender, first_name, middle_initial, last_name, street_address, city, state, postcode, email, birthday, team_id, team_type) values('female','Shannon','L','Manning','60 Ocean Pde','Greenvale','QLD','4816','Shannon.L.Manning@dodgit.com','1956/6/13 00:00:00', 3, 'FootballTeam');
-insert into `people` (gender, first_name, middle_initial, last_name, street_address, city, state, postcode, email, birthday, team_id, team_type) values('male','Oscar','C','Lawson','43 Feather Street','Battery Hill','QLD','4551','Oscar.C.Lawson@spambob.com','1979/10/17 00:00:00', 3, 'CricketTeam');
-insert into `people` (gender, first_name, middle_initial, last_name, street_address, city, state, postcode, email, birthday, team_id, team_type) values('female','Sofia','K','Bray','26 Clifton Street','Pental Island','VIC','3586','Sofia.K.Bray@mailinator.com','1970/5/10 00:00:00', 3, 'CricketTeam');
-insert into `people` (gender, first_name, middle_initial, last_name, street_address, city, state, postcode, email, birthday, team_id, team_type) values('male','Andrew','N','Byrne','35 Cecil Street','Monash Park','NSW','2111','Andrew.N.Byrne@spambob.com','1983/2/16 00:00:00', 3, 'CricketTeam');
-
-insert into `alphas` (name) values ('one');
-insert into `alphas` (name) values ('two');
-insert into `alphas` (name) values ('three');
-insert into `alphas` (name) values ('four');
-insert into `alphas` (name) values ('five');
-insert into `alphas` (name) values ('six');
-insert into `alphas` (name) values ('seven');
-insert into `alphas` (name) values ('eight');
-insert into `alphas` (name) values ('nine');
-insert into `alphas` (name) values ('ten');
-
-insert into `betas` (name) values ('one');
-insert into `betas` (name) values ('two');
-insert into `betas` (name) values ('three');
-insert into `betas` (name) values ('four');
-insert into `betas` (name) values ('five');
-insert into `betas` (name) values ('six');
-insert into `betas` (name) values ('seven');
-insert into `betas` (name) values ('eight');
-insert into `betas` (name) values ('nine');
-insert into `betas` (name) values ('ten');

data/spec/fixtures/database.yml.default

@@ -1,3 +0,0 @@
-username: root
-password: 
-host: localhost

data/spec/fixtures/models.rb

@@ -1,161 +0,0 @@
-class Tag < ActiveRecord::Base
-  belongs_to :person
-  belongs_to :football_team
-  belongs_to :cricket_team
-end
-
-class FootballTeam < ActiveRecord::Base
-  has_many :tags
-  has_many :people, :through => :tags
-end
-
-class CricketTeam < ActiveRecord::Base
-  has_many :people, :foreign_key => :team_id
-
-  define_index do
-    indexes :name
-    has "SELECT cricket_team_id, id FROM tags", :source => :query, :as => :tags
-  end
-end
-
-class Contact < ActiveRecord::Base
-  belongs_to :person
-end
-
-class Friendship < ActiveRecord::Base
-  belongs_to :person
-  belongs_to :friend, :class_name => "Person", :foreign_key => :friend_id
-  
-  define_index do
-    indexes "'something'", :as => :something
-    has person_id, friend_id
-    
-    set_property :latitude_attr   => :person_id
-    set_property :longitude_attr  => :person_id
-  end
-  
-  sphinx_scope(:reverse) {
-    {:order => "@weight ASC"}
-  }
-end
-
-class Link < ActiveRecord::Base
-  has_and_belongs_to_many :people
-end
-
-class Person < ActiveRecord::Base
-  belongs_to :team, :polymorphic => :true
-  belongs_to :source, :polymorphic => :true
-  has_many :contacts
-  
-  has_many :friendships
-  has_many :friends, :through => :friendships
-  
-  has_many :tags
-  has_many :football_teams, :through => :tags
-  
-  has_and_belongs_to_many :links
-  
-  define_index do
-    indexes [first_name, middle_initial, last_name], :as => :name
-    indexes team.name, :as => :team_name
-    indexes contacts.phone_number, :as => :phone_numbers
-    indexes city,   :prefixes => true, :facet => true
-    indexes state,  :infixes  => true, :facet => true
-    
-    has [first_name, middle_initial, last_name], :as => :name_sort
-    has team.name, :as => :team_name_sort
-    
-    has [:id, :team_id], :as => :ids
-    has team(:id), :as => :team_id
-    has football_teams(:id), :as => :football_team_id
-    
-    has contacts.phone_number, :as => :phone_number_sort
-    has contacts(:id), :as => :contact_ids
-    
-    has birthday, :facet => true
-    
-    has friendships.person_id, :as => :friendly_ids
-    
-    has :id, :as => :latitude
-    has :id, :as => :longitude
-    
-    set_property :delta => true
-  end
-end
-
-class Parent < Person
-end
-
-module Admin
-  class Person < ::Person
-  end
-end
-
-class Child < Person
-  belongs_to :parent
-  define_index do
-    indexes [parent.first_name, parent.middle_initial, parent.last_name], :as => :parent_name
-  end
-end
-
-class Alpha < ActiveRecord::Base
-  has_many :betas
-  has_many :thetas
-  
-  define_index do
-    indexes :name, :sortable => true
-    
-    has :id, :as => :lat
-    has :id, :as => :lng
-    
-    set_property :field_weights => {"name" => 10}
-  end
-  
-  def big_name
-    name.upcase
-  end
-  
-  def sphinx_attributes
-    :existing
-  end
-end
-
-class Beta < ActiveRecord::Base
-  has_many :gammas
-  
-  define_index do
-    indexes :name, :sortable => true
-    
-    has :id, :as => :lat
-    has :id, :as => :lon
-    
-    set_property :delta => true
-  end
-  
-  def excerpts
-    false
-  end
-  
-  def matching_fields
-    :foo
-  end
-end
-
-class Gamma < ActiveRecord::Base
-  #
-end
-
-class Theta < ActiveRecord::Base
-  #
-end
-
-class Search < ActiveRecord::Base
-  #
-end
-
-class BigFoo < ActiveRecord::Base
-  define_index do
-    indexes name
-  end
-end