thinking-sphinx 1.5.0 → 2.0.0.rc1

data/spec/fixtures/structure.sql

@@ -1,146 +0,0 @@
-DROP TABLE IF EXISTS `people`;
-
-CREATE TABLE `people` (
-  `id` int(11) NOT NULL auto_increment,
-  `first_name` varchar(50) NULL,
-  `middle_initial` varchar(10) NULL,
-  `last_name` varchar(50) NULL,
-  `gender` varchar(10) NULL,
-  `street_address` varchar(200) NULL,
-  `city` varchar(100) NULL,
-  `state` varchar(100) NULL,
-  `postcode` varchar(10) NULL,
-  `email` varchar(100) NULL,
-  `birthday` datetime NULL,
-  `team_id` int(11) NULL,
-  `team_type` varchar(50) NULL,
-  `type` varchar(50) NULL,
-  `parent_id` varchar(50) NULL,
-  `source_id` int(11) NULL,
-  `source_type` varchar(50) NULL,
-  `delta` tinyint(1) NOT NULL DEFAULT 0,
-  PRIMARY KEY  (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-
-DROP TABLE IF EXISTS `friendships`;
-
-CREATE TABLE `friendships` (
-  `id` int(11) NOT NULL auto_increment,
-  `person_id` int(11) NOT NULL,
-  `friend_id` int(11) NOT NULL,
-  `created_at` datetime NOT NULL,
-  `created_on` date NULL,
-  `updated_at` datetime NOT NULL,
-  PRIMARY KEY (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-
-DROP TABLE IF EXISTS `football_teams`;
-
-CREATE TABLE `football_teams` (
-  `id` int(11) NOT NULL auto_increment,
-  `name` varchar(50) NOT NULL,
-  `state` varchar(50) NOT NULL,
-  `league` varchar(50) NOT NULL,
-  PRIMARY KEY (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-
-DROP TABLE IF EXISTS `cricket_teams`;
-
-CREATE TABLE `cricket_teams` (
-  `id` int(11) NOT NULL auto_increment,
-  `name` varchar(50) NOT NULL,
-  `state` varchar(50) NOT NULL,
-  PRIMARY KEY (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-
-DROP TABLE IF EXISTS `contacts`;
-
-CREATE TABLE `contacts` (
-  `id` int(11) NOT NULL auto_increment,
-  `phone_number` varchar(50) NOT NULL,
-  `person_id` int(11) NOT NULL,
-  PRIMARY KEY (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-
-DROP TABLE IF EXISTS `alphas`;
-
-CREATE TABLE `alphas` (
-  `id` int(11) NOT NULL auto_increment,
-  `name` varchar(50) NOT NULL,
-  `value` int(11),
-  `cost` decimal(10,6),
-  PRIMARY KEY (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-
-DROP TABLE IF EXISTS `betas`;
-
-CREATE TABLE `betas` (
-  `id` int(11) NOT NULL auto_increment,
-  `name` varchar(50) NOT NULL,
-  `alpha_id` int(11),
-  `delta` tinyint(1) NOT NULL DEFAULT 0,
-  PRIMARY KEY (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-
-DROP TABLE IF EXISTS `gammas`;
-
-CREATE TABLE `gammas` (
-  `id` int(11) NOT NULL auto_increment,
-  `name` varchar(50) NOT NULL,
-  `value` int(11),
-  `beta_id` int(11),
-  PRIMARY KEY (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-
-DROP TABLE IF EXISTS `thetas`;
-
-CREATE TABLE `thetas` (
-  `id` int(11) NOT NULL auto_increment,
-  `name` varchar(50) NOT NULL,
-  `value` int(11),
-  `alpha_id` int(11),
-  PRIMARY KEY (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-
-DROP TABLE IF EXISTS `searches`;
-
-CREATE TABLE `searches` (
-  `id` int(11) NOT NULL auto_increment,
-  `name` varchar(50) NOT NULL,
-  PRIMARY KEY (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-
-DROP TABLE IF EXISTS `tags`;
-
-CREATE TABLE `tags` (
-  `id` int(11) NOT NULL auto_increment,
-  `person_id` int(11) NOT NULL,
-  `football_team_id` int(11) NOT NULL,
-  `cricket_team_id` int(11) NOT NULL,
-  `name` varchar(50) NOT NULL,
-  PRIMARY KEY (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-
-DROP TABLE IF EXISTS `links`;
-
-CREATE TABLE `links` (
-  `id` int(11) NOT NULL auto_increment,
-  `url` varchar(50) NOT NULL,
-  `description` varchar(200),
-  PRIMARY KEY (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-
-DROP TABLE IF EXISTS `links_people`;
-
-CREATE TABLE `links_people` (
-  `link_id` int(11) NOT NULL,
-  `person_id` int(11) NOT NULL
-) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-
-DROP TABLE IF EXISTS `big_foos`;
-
-CREATE TABLE `big_foos` (
-  `id` bigint NOT NULL auto_increment,
-  `name` varchar(50) NOT NULL,
-  PRIMARY KEY (`id`)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8;

data/spec/spec_helper.rb

@@ -1,54 +0,0 @@
-$:.unshift File.dirname(__FILE__) + '/../lib'
-
-require 'rubygems'
-require 'fileutils'
-require 'bundler'
-
-Bundler.require :default, :development
-
-require "#{File.dirname(__FILE__)}/sphinx_helper"
-
-ActiveRecord::Base.logger = Logger.new(StringIO.new)
-
-RSpec.configure do |config|
-  %w( tmp tmp/config tmp/log tmp/db ).each do |path|
-    FileUtils.mkdir_p "#{Dir.pwd}/#{path}"
-  end
-
-  Kernel.const_set :RAILS_ROOT, "#{Dir.pwd}/tmp" unless defined?(RAILS_ROOT)
-
-  sphinx = SphinxHelper.new
-  sphinx.setup_mysql
-
-  require "#{File.dirname(__FILE__)}/fixtures/models"
-  ThinkingSphinx.context.define_indexes
-
-  config.before :each do
-    %w( tmp tmp/config tmp/log tmp/db ).each do |path|
-      FileUtils.mkdir_p "#{Dir.pwd}/#{path}"
-    end
-
-    ThinkingSphinx.updates_enabled = true
-    ThinkingSphinx.deltas_enabled = true
-    ThinkingSphinx.suppress_delta_output = true
-
-    ThinkingSphinx::Configuration.instance.reset
-  end
-
-  config.after :all do
-    FileUtils.rm_r "#{Dir.pwd}/tmp" rescue nil
-  end
-end
-
-def minimal_result_hashes(*instances)
-  instances.collect do |instance|
-    {
-      :weight     => 21,
-      :attributes => {
-        'sphinx_internal_id'    => instance.id,
-        'sphinx_internal_class' => instance.class.name,
-        'class_crc'             => instance.class.name.to_crc32
-      }
-    }
-  end
-end

data/spec/sphinx_helper.rb

@@ -1,67 +0,0 @@
-require 'active_record'
-prefix = defined?(JRUBY_VERSION) ? "jdbc" : ""
-require "active_record/connection_adapters/#{prefix}mysql_adapter"
-require "active_record/connection_adapters/mysql2_adapter"
-
-begin
-  require "active_record/connection_adapters/#{prefix}postgresql_adapter"
-rescue LoadError
-  # No postgres?  no prob...
-end
-require 'yaml'
-
-class SphinxHelper
-  attr_accessor :host, :username, :password, :socket
-  attr_reader   :path
-
-  def initialize
-    @host     = 'localhost'
-    @username = 'root'
-    @password = ''
-
-    if File.exist?('spec/fixtures/database.yml')
-      config    = YAML.load(File.open('spec/fixtures/database.yml'))
-      @host     = config['host']
-      @username = config['username']
-      @password = config['password']
-      @socket   = config['socket']
-      @sslca    = config['sslca']
-      @sslcert  = config['sslcert']
-      @sslkey   = config['sslkey']
-    end
-
-    @path = File.expand_path(File.dirname(__FILE__))
-  end
-
-  def setup_mysql
-    ActiveRecord::Base.establish_connection(
-      :adapter  => mysql_adapter,
-      :database => 'thinking_sphinx',
-      :username => @username,
-      :password => @password,
-      :host     => @host,
-      :socket   => @socket,
-      :sslca    => @sslca,
-      :sslcert  => @sslcert,
-      :sslkey   => @sslkey
-    )
-    ActiveRecord::Base.logger = Logger.new(File.open('tmp/activerecord.log', 'a'))
-
-    structure = File.open('spec/fixtures/structure.sql') { |f| f.read.chomp }
-    structure.split(';').each { |table|
-      ActiveRecord::Base.connection.execute table
-    }
-
-    File.open('spec/fixtures/data.sql') { |f|
-      while line = f.gets
-        ActiveRecord::Base.connection.execute line unless line.blank?
-      end
-    }
-  end
-
-  private
-
-  def mysql_adapter
-    defined?(JRUBY_VERSION) ? 'jdbcmysql' : 'mysql2'
-  end
-end

data/spec/thinking_sphinx/adapters/abstract_adapter_spec.rb

@@ -1,163 +0,0 @@
-require 'spec_helper'
-
-class CustomAdapter < ThinkingSphinx::AbstractAdapter
-  #
-end
-
-describe ThinkingSphinx::AbstractAdapter do
-  describe '.detect' do
-    let(:model) { stub('model') }
-
-    it "returns a MysqlAdapter object for :mysql" do
-      ThinkingSphinx::AbstractAdapter.stub(:adapter_for_model => :mysql)
-
-      adapter = ThinkingSphinx::AbstractAdapter.detect(model)
-      adapter.should be_a(ThinkingSphinx::MysqlAdapter)
-    end
-
-    it "returns a PostgreSQLAdapter object for :postgresql" do
-      ThinkingSphinx::AbstractAdapter.stub(:adapter_for_model => :postgresql)
-
-      adapter = ThinkingSphinx::AbstractAdapter.detect(model)
-      adapter.should be_a(ThinkingSphinx::PostgreSQLAdapter)
-    end
-
-    it "instantiates the provided class if one is provided" do
-      ThinkingSphinx::AbstractAdapter.stub(:adapter_for_model => CustomAdapter)
-      CustomAdapter.should_receive(:new).and_return(stub('adapter'))
-
-      ThinkingSphinx::AbstractAdapter.detect(model)
-    end
-
-    it "raises an exception for other responses" do
-      ThinkingSphinx::AbstractAdapter.stub(:adapter_for_model => :sqlite)
-
-      lambda {
-        ThinkingSphinx::AbstractAdapter.detect(model)
-      }.should raise_error
-    end
-  end
-
-  describe '.adapter_for_model' do
-    let(:model) { stub('model') }
-
-    after :each do
-      ThinkingSphinx.database_adapter = nil
-    end
-
-    it "translates strings to symbols" do
-      ThinkingSphinx.database_adapter = 'foo'
-
-      ThinkingSphinx::AbstractAdapter.adapter_for_model(model).should == :foo
-    end
-
-    it "passes through symbols unchanged" do
-      ThinkingSphinx.database_adapter = :bar
-
-      ThinkingSphinx::AbstractAdapter.adapter_for_model(model).should == :bar
-    end
-
-    it "returns standard_adapter_for_model if database_adapter is not set" do
-      ThinkingSphinx.database_adapter = nil
-      ThinkingSphinx::AbstractAdapter.stub!(:standard_adapter_for_model => :baz)
-
-      ThinkingSphinx::AbstractAdapter.adapter_for_model(model).should == :baz
-    end
-
-    it "calls the lambda and returns it if one is provided" do
-      ThinkingSphinx.database_adapter = lambda { |model| :foo }
-
-      ThinkingSphinx::AbstractAdapter.adapter_for_model(model).should == :foo
-    end
-  end
-
-  describe '.standard_adapter_for_model' do
-    let(:klass)      { stub('connection class') }
-    let(:connection) { stub('connection', :class => klass) }
-    let(:model)      { stub('model', :connection => connection) }
-
-    it "translates a normal MySQL adapter" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::MysqlAdapter')
-
-      ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
-        should == :mysql
-    end
-
-    it "translates a MySQL plus adapter" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::MysqlplusAdapter')
-
-      ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
-        should == :mysql
-    end
-
-    it "translates a MySQL2 adapter" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::Mysql2Adapter')
-
-      ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
-        should == :mysql
-    end
-
-    it "translates a NullDB adapter to MySQL" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::NullDBAdapter')
-
-      ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
-        should == :mysql
-    end
-
-    it "translates a normal PostgreSQL adapter" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::PostgreSQLAdapter')
-
-      ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
-        should == :postgresql
-    end
-
-    it "translates a JDBC MySQL adapter to MySQL" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
-      connection.stub(:config => {:adapter => 'jdbcmysql'})
-
-      ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
-        should == :mysql
-    end
-
-    it "translates a JDBC PostgreSQL adapter to PostgreSQL" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
-      connection.stub(:config => {:adapter => 'jdbcpostgresql'})
-
-      ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
-        should == :postgresql
-    end
-
-   it "translates a JDBC adapter with MySQL connection string to MySQL" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
-      connection.stub(:config => {:adapter => 'jdbc',
-                                  :url => 'jdbc:mysql://127.0.0.1:3306/sphinx'})
-
-      ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
-        should == :mysql
-    end
-
-    it "translates a JDBC adapter with PostgresSQL connection string to PostgresSQL" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
-      connection.stub(:config => {:adapter => 'jdbc',
-                                  :url => 'jdbc:postgresql://127.0.0.1:3306/sphinx'})
-
-      ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
-        should == :postgresql
-    end
-
-    it "returns other JDBC adapters without translation" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
-      connection.stub(:config => {:adapter => 'jdbcmssql'})
-
-      ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
-        should == :jdbcmssql
-    end
-
-    it "returns other unknown adapters without translation" do
-      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::FooAdapter')
-
-      ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
-        should == 'ActiveRecord::ConnectionAdapters::FooAdapter'
-    end
-  end
-end

data/spec/thinking_sphinx/connection_spec.rb

@@ -1,77 +0,0 @@
-require 'spec_helper'
-
-describe ThinkingSphinx::Connection do
-  describe '#client' do
-    let(:connection) { ThinkingSphinx::Connection.new }
-
-    before :each do
-      @config = ThinkingSphinx::Configuration.instance
-      @config.address     = 'domain.url'
-      @config.port        = 3333
-      @config.configuration.searchd.max_matches = 100
-      @config.timeout = 1
-
-      pending
-    end
-
-    it "should return an instance of Riddle::Client" do
-      connection.client.should be_a(Riddle::Client)
-    end
-
-    it "should use the configuration address" do
-      connection.client.server.should == 'domain.url'
-    end
-
-    it "should use the configuration port" do
-      connection.client.port.should == 3333
-    end
-
-    it "should use the configuration max matches" do
-      connection.client.max_matches.should == 100
-    end
-
-    it "should use the configuration timeout" do
-      connection.client.timeout.should == 1
-    end
-
-    describe 'when shuffle is enabled' do
-      let(:client) { double('client', :max_matches= => nil, :timeout= => nil,
-        :open => true) }
-
-      before :each do
-        @config.shuffle = true
-      end
-
-      it "should shuffle client servers" do
-        @config.address = ['1.1.1.1', '2.2.2.2']
-        @config.address.stub!(:shuffle => ['2.2.2.2', '1.1.1.1'])
-
-        Riddle::Client.should_receive(:new) do |addresses, port, key|
-          addresses.should == ['2.2.2.2', '1.1.1.1']
-          client
-        end
-        connection.client
-      end
-    end
-
-    describe 'when shuffle is disabled' do
-      let(:client) { double('client', :max_matches= => nil, :timeout= => nil,
-        :open => true) }
-
-      before :each do
-        @config.shuffle = false
-      end
-
-      it "should not shuffle client servers" do
-        @config.address = ['1.1.1.1', '2.2.2.2.', '3.3.3.3', '4.4.4.4', '5.5.5.5']
-
-        @config.address.should_not_receive(:shuffle)
-        Riddle::Client.should_receive(:new) do |addresses, port, key|
-          addresses.should == ['1.1.1.1', '2.2.2.2.', '3.3.3.3', '4.4.4.4', '5.5.5.5']
-          client
-        end
-        connection.client
-      end
-    end
-  end
-end