dm-sphinx-adapter 0.5 → 0.6

data/lib/dm-sphinx-adapter/config_parser.rb

@@ -1,71 +0,0 @@
-require 'rubygems'
-
-gem 'extlib', '~> 0.9.7'
-require 'extlib'
-
-require 'pathname'
-require 'strscan'
-
-module DataMapper
-  module Adapters
-    module Sphinx
-      module ConfigParser
-        extend Extlib::Assertions
-
-        # Parse a sphinx config file and return searchd options as a hash.
-        #
-        # ==== Raises
-        # RuntimeError:: On parsing errors.
-        #
-        # ==== Parameters
-        # path<String>:: Sphinx configuration file.
-        #
-        # ==== Returns
-        # Hash:: Searchd options.
-        def self.parse(path)
-          assert_kind_of 'path', path, Pathname, String
-
-          config = Pathname(path).read
-          config.gsub!(/\r\n|\r|\n/, "\n") # Everything in \n
-          config.gsub!(/\s*\\\n\s*/, ' ')  # Remove unixy line wraps.
-
-          blocks(StringScanner.new(config), out = [])
-          out.find{|c| c['type'] =~ /searchd/i} || {}
-        end
-
-        protected
-          def self.blocks(conf, out = []) #:nodoc:
-            if conf.scan(/\#[^\n]*\n/) || conf.scan(/\s+/)
-              blocks(conf, out)
-            elsif conf.scan(/indexer|searchd|source|index/i)
-              out << group = {'type' => conf.matched}
-              if conf.matched =~ /^(?:index|source)$/i
-                conf.scan(/\s* ([\w_\-]+) (?:\s*:\s*([\w_\-]+))? \s*/x) or raise "Expected #{group[:type]} name."
-                group['name']     = conf[1]
-                group['ancestor'] = conf[2]
-              end
-              conf.scan(/\s*\{/) or raise %q{Expected '\{'.}
-              pairs(conf, kv = {})
-              group.merge!(kv)
-              conf.scan(/\s*\}/) or raise %q{Expected '\}'.}
-              blocks(conf, out)
-            else
-              raise "Unknown near: #{conf.peek(30)}" unless conf.eos?
-            end
-          end
-
-          def self.pairs(conf, out = {}) #:nodoc:
-            if conf.scan(/\#[^\n]*\n/) || conf.scan(/\s+/)
-              pairs(conf, out)
-            elsif conf.scan(/[\w_-]+/)
-              key = conf.matched
-              conf.scan(/\s*=/) or raise %q{Expected '='.}
-              out[key] = conf.scan(/[^\n]*\n/).strip
-              pairs(conf, out)
-            end
-          end
-      end # ConfigParser
-    end # Sphinx
-  end # Adapters
-end # DataMapper
-

data/test/files/dm_sphinx_adapter_test.sql

@@ -1,21 +0,0 @@
-drop table if exists delta;
-create table delta (
-  name varchar(50) not null,
-  updated_on datetime,
-  primary key (name)
-) engine=innodb default charset=utf8;
-
-drop table if exists items;
-create table items (
-  id int(11) not null auto_increment,
-  name varchar(50) not null,
-  likes text not null,
-  updated_on datetime,
-  primary key (id),
-  index (updated_on)
-) engine=innodb default charset=utf8;
-
-insert into items (name, likes, updated_on) values
-  ('one', 'I really like one!', now()),
-  ('two', 'I really like two!', now()),
-  ('three', 'I really like three!', now());

data/test/files/resource_explicit.rb

@@ -1,25 +0,0 @@
-require 'rubygems'
-require 'dm-is-searchable'
-
-class Explicit
-  include DataMapper::Resource
-  include DataMapper::SphinxResource
-
-  property :id,         Serial
-  property :name,       String
-  property :likes,      Text, :lazy => false
-  property :updated_on, DateTime
-
-  is :searchable
-  repository(:search) do
-    properties(:search).clear
-    index     :items
-    index     :items_delta, :delta => true
-    property  :name,    String
-    attribute :updated_on, DateTime
-  end
-
-  def self.default_storage_name
-    'item'
-  end
-end # Explicit

data/test/files/resource_resource.rb

@@ -1,19 +0,0 @@
-require 'rubygems'
-require 'dm-is-searchable'
-
-class Resource
-  include DataMapper::Resource
-  include DataMapper::SphinxResource
-
-  property :id,         Serial
-  property :name,       String
-  property :likes,      Text, :lazy => false
-  property :updated_on, DateTime
-
-  is :searchable
-
-  def self.default_storage_name
-    'item'
-  end
-end # Resource
-

data/test/files/resource_searchable.rb

@@ -1,16 +0,0 @@
-require 'rubygems'
-require 'dm-is-searchable'
-
-class Searchable
-  include DataMapper::Resource
-  property :id,         Serial
-  property :name,       String
-  property :likes,      Text, :lazy => false
-  property :updated_on, DateTime
-
-  is :searchable
-
-  def self.default_storage_name
-    'item'
-  end
-end # Searchable

data/test/files/resource_storage_name.rb

@@ -1,11 +0,0 @@
-class StorageName
-  include DataMapper::Resource
-  property :id,         Serial
-  property :name,       String
-  property :likes,      Text, :lazy => false
-  property :updated_on, DateTime
-
-  def self.default_storage_name
-    'item'
-  end
-end # StorageName

data/test/files/resource_vanilla.rb

@@ -1,7 +0,0 @@
-class Vanilla
-  include DataMapper::Resource
-  property :id,         Serial
-  property :name,       String
-  property :likes,      Text, :lazy => false
-  property :updated_on, DateTime
-end # Vanilla

data/test/files/sphinx.conf

@@ -1,78 +0,0 @@
-# searchd and indexer must be run from the root directory of this lib.
-
-indexer
-{
-  mem_limit = 64M
-}
-
-searchd
-{
-  address      = localhost
-  port         = 3312
-  log          = test/var/sphinx.log
-  query_log    = test/var/sphinx.query.log
-  read_timeout = 5
-  pid_file     = test/var/sphinx.pid
-  max_matches  = 1000
-}
-
-source items
-{
-  type     = mysql
-  sql_host = localhost
-  sql_user = root
-  sql_pass =
-  sql_db   = dm_sphinx_adapter_test
-
-  sql_query_pre = set names utf8
-  sql_query_pre = \
-    replace into delta (name, updated_on) ( \
-      select 'items', updated_on \
-      from items \
-      order by updated_on desc \
-      limit 1\
-    )
-
-  sql_query = \
-    select id, name, likes, unix_timestamp(updated_on) as updated_on \
-    from items \
-    where updated_on <= ( \
-      select updated_on \
-      from delta \
-      where name = 'items'\
-    )
-
-  sql_query_info = select * from items where id = $id
-  sql_attr_timestamp = updated_on
-}
-
-source items_delta : items
-{
-  sql_query_pre = set names utf8
-  sql_query = \
-    select id, name, likes, unix_timestamp(updated_on) as updated_on \
-    from items \
-    where updated_on > ( \
-      select updated_on \
-      from delta \
-      where name = 'items'\
-    )
-}
-
-index items
-{
-  source = items
-  path   = test/var/sphinx/items
-}
-
-index items_delta : items
-{
-  source = items_delta
-  path   = test/var/sphinx/items_delta
-}
-
-index vanillas
-{
-  type  = distributed
-  local = items
-}

data/test/test_adapter_explicit.rb

@@ -1,48 +0,0 @@
-require 'test_adapter'
-require 'files/resource_explicit'
-
-class TestAdapterExplicit < TestAdapter
-  def setup
-    super
-    DataMapper.setup(:search, :adapter => 'sphinx', :config => @config, :managed => true)
-  end
-
-  def teardown
-    DataMapper.repository(:search).adapter.client.stop
-    super
-  end
-
-  def test_initialize
-    assert_nothing_raised{ Explicit.new }
-  end
-
-  def test_search_properties
-    assert_equal Explicit.all, Explicit.search
-    assert_equal [Explicit.first(:id => 2)], Explicit.search(:name => 'two')
-  end
-
-  def test_search_delta
-    resource = Explicit.create(:name => 'four', :likes => 'chicken', :updated_on => Time.now)
-    DataMapper.repository(:search).adapter.client.index('items_delta')
-    assert_equal [resource], Explicit.search(:name => 'four')
-  end
-
-  def test_search_attribute_timestamp
-    time     = Time.now
-    resource = Explicit.create(:name => 'four', :likes => 'chicken', :updated_on => time)
-    DataMapper.repository(:search).adapter.client.index('items_delta')
-
-    assert_equal [resource], Explicit.search(:updated_on => time.to_i)
-    assert_equal [resource], Explicit.search(:updated_on => (time .. time + 1))
-    assert_equal [], Explicit.search(:updated_on => (time - 60 * 60))
-    assert_equal [], Explicit.search(:updated_on => (time + 60 * 60))
-  end
-
-  def test_search_attribute_boolean
-    # TODO:
-  end
-
-  def test_search_attribute_integer
-    # TODO
-  end
-end # TestAdapterExplicit

data/test/test_adapter_resource.rb

@@ -1,25 +0,0 @@
-require 'test_adapter'
-require 'files/resource_resource'
-
-class TestAdapterResource < TestAdapter
-  def setup
-    super
-    DataMapper.setup(:search, :adapter => 'sphinx', :config => @config, :managed => true)
-  end
-
-  def teardown
-    DataMapper.repository(:search).adapter.client.stop
-    super
-  end
-
-  def test_initialize
-    assert_nothing_raised{ Resource.new }
-  end
-
-  def test_search_properties
-    assert_equal Resource.all, Resource.search
-    assert_equal [Resource.first(:id => 2)], Resource.search(:name => 'two')
-    assert_equal [Resource.first(:id => 2)], Resource.search(:conditions => ['two'])
-  end
-end # TestAdapterResource
-

data/test/test_adapter_searchable.rb

@@ -1,23 +0,0 @@
-require 'test_adapter'
-require 'files/resource_searchable'
-
-class TestAdapterSearchable < TestAdapter
-  def setup
-    super
-    DataMapper.setup(:search, :adapter => 'sphinx', :config => @config, :managed => true)
-  end
-
-  def teardown
-    DataMapper.repository(:search).adapter.client.stop
-    super
-  end
-
-  def test_initialize
-    assert_nothing_raised{ Searchable.new }
-  end
-
-  def test_search
-    assert_equal Searchable.all, Searchable.search
-    assert_equal [Searchable.first(:id => 2)], Searchable.search(:name => 'two')
-  end
-end # TestAdapterSearchable

data/test/test_adapter_vanilla.rb

@@ -1,46 +0,0 @@
-require 'test_adapter'
-require 'files/resource_vanilla'
-require 'files/resource_storage_name'
-
-class TestAdapterVanilla < TestAdapter
-  def setup
-    super
-    DataMapper.setup(:default, :adapter => 'sphinx', :config => @config, :managed => true)
-  end
-
-  def teardown
-    DataMapper.repository(:default).adapter.client.stop
-    super
-  end
-
-  def test_initialize
-    assert_nothing_raised{ Vanilla.new }
-    assert_nothing_raised{ StorageName.new }
-  end
-
-  def test_all
-    assert_equal [{:id => 1}, {:id => 2}, {:id => 3}], Vanilla.all
-    assert_equal [{:id => 1}], Vanilla.all(:name => 'one')
-  end
-
-  def test_all_limit
-    assert_equal [{:id => 1}], Vanilla.all(:limit => 1)
-    assert_equal [{:id => 1}, {:id => 2}], Vanilla.all(:limit => 2)
-  end
-
-  def test_all_offset
-    assert_equal [{:id => 1}, {:id => 2}, {:id => 3}], Vanilla.all(:offset => 0)
-    assert_equal [{:id => 2}, {:id => 3}], Vanilla.all(:offset => 1)
-    assert_equal [], Vanilla.all(:offset => 3)
-  end
-
-  def test_first
-    assert_equal({:id => 1}, Vanilla.first(:name => 'one'))
-    assert_nil Vanilla.first(:name => 'missing')
-  end
-
-  def test_storage_name
-    assert_equal Vanilla.all, StorageName.all
-    assert_equal Vanilla.first, StorageName.first
-  end
-end

data/test/test_client.rb

@@ -1,31 +0,0 @@
-require 'test_adapter'
-
-class TestClient < TestAdapter
-  def test_initialize
-    assert_nothing_raised { DataMapper::Adapters::Sphinx::Client.new(@config) }
-  end
-
-  def test_index
-    client = DataMapper::Adapters::Sphinx::Client.new(@config)
-    assert_nothing_raised{ client.index }
-    assert_nothing_raised{ client.index 'items' }
-    assert_nothing_raised{ client.index '*' }
-    assert_nothing_raised{ client.index ['items', 'items_delta'] }
-  end
-
-  def test_managed_initialize
-    assert_nothing_raised { DataMapper::Adapters::Sphinx::ManagedClient.new(@config) }
-  end
-
-  def test_search
-    begin
-      client = DataMapper::Adapters::Sphinx::ManagedClient.new(@config)
-      client.index
-      assert match = client.search('two')
-      assert_equal 1, match[:total]
-      assert_equal 2, match[:matches][0][:doc]
-    ensure
-      client.stop
-    end
-  end
-end # TestClient

data/test/test_config.rb

@@ -1,75 +0,0 @@
-require 'test/unit'
-require 'dm-sphinx-adapter'
-
-class TestConfig < Test::Unit::TestCase
-  def setup
-    base    = Pathname(__FILE__).dirname.expand_path
-    @config = base / 'files' / 'sphinx.conf'
-    @log    = base / 'var' / 'sphinx.log'
-  end
-
-  def test_initialize
-    assert_nothing_raised{ config }
-    assert_nothing_raised{ config({}) }
-    assert_nothing_raised{ config(:config => nil) }
-    assert_nothing_raised{ config(:config => 'blah') }
-    assert_nothing_raised{ config(:config => @log) }
-  end
-
-  def test_initalize_defaults
-    assert c = config({})
-    assert_equal '0.0.0.0', c.address
-    assert_equal 3312, c.port
-    assert_equal 'searchd.log', c.log
-    assert_raise(RuntimeError){ c.pid_file }
-    assert_nil c.config
-  end
-
-  def test_initalize_options_hash
-    assert c = config(
-      :host     => 'options',
-      :port     => 1234,
-      :log      => 'log.log',
-      :pid_file => 'pid.pid'
-    )
-
-    assert_equal 'options', c.address
-    assert_equal 1234, c.port
-    assert_equal 'log.log', c.log
-    assert_equal 'pid.pid', c.pid_file
-    assert_nil c.config
-  end
-
-  def test_initialize_options_string
-    assert c = config("sphinx://options:1234")
-    assert_equal 'options', c.address
-    assert_equal 1234, c.port
-    assert_equal 'searchd.log', c.log
-    assert_raise(RuntimeError){ c.pid_file }
-    assert_nil c.config
-  end
-
-  def test_initialize_config
-    assert c = config(:config => @config)
-    assert_equal 'localhost', c.address
-    assert_equal '3312', c.port
-    assert_equal 'test/var/sphinx.log', c.log
-    assert_equal 'test/var/sphinx.pid', c.pid_file
-    assert_equal @config, c.config
-  end
-
-  def test_initialize_database_hash
-    assert c = config(:database => @config)
-    assert_equal @config, c.config
-  end
-
-  def test_initialize_database_string
-    assert c = config("sphinx://localhost/test/files/sphinx.conf")
-    assert_equal @config, c.config
-  end
-
-  protected
-    def config(options = {:config => @config})
-      DataMapper::Adapters::Sphinx::Config.new(options)
-    end
-end # TestConfig