shanna-dm-sphinx-adapter 0.5 → 0.6

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

@@ -1,74 +0,0 @@
-require 'rubygems'
-
-gem 'extlib', '~> 0.9.7'
-require 'extlib'
-
-module DataMapper
-  module Adapters
-    module Sphinx
-      class Config
-        include Extlib::Assertions
-        attr_reader :config, :address, :log, :port
-
-        ##
-        # Read a sphinx configuration file.
-        #
-        # This class just gives you access to handy searchd {} configuration options.
-        #
-        # @see http://www.sphinxsearch.com/doc.html#confgroup-searchd
-        def initialize(uri_or_options = {})
-          assert_kind_of 'uri_or_options', uri_or_options, Addressable::URI, DataObjects::URI, Hash, String, Pathname
-
-          options   = normalize_options(uri_or_options)
-          config    = parse_config("#{options[:path]}") # Pathname#to_s is broken?
-          @address  = options[:host]     || config['address']  || '0.0.0.0'
-          @port     = options[:port]     || config['port']     || 3312
-          @log      = options[:log]      || config['log']      || 'searchd.log'
-          @pid_file = options[:pid_file] || config['pid_file']
-        end
-
-        ##
-        # Indexer binary full path name and config argument.
-        def indexer_bin(use_config = true)
-          path = 'indexer' # TODO: Real.
-          path << " --config #{config}" if config
-          path
-        end
-
-        ##
-        # Searchd binary full path name and config argument.
-        def searchd_bin(use_config = true)
-          path = 'searchd' # TODO: Real.
-          path << " --config #{config}" if config
-          path
-        end
-
-        def pid_file
-          @pid_file or raise "Mandatory pid_file option missing from searchd configuration."
-        end
-
-        protected
-          def normalize_options(uri_or_options)
-            case uri_or_options
-              when String, Addressable::URI then DataObjects::URI.parse(uri_or_options).attributes
-              when DataObjects::URI         then uri_or_options.attributes
-              when Pathname                 then {:path => uri_or_options}
-              else
-                uri_or_options[:path] ||= uri_or_options.delete(:config) || uri_or_options.delete(:database)
-                uri_or_options
-            end
-          end
-
-          def parse_config(path)
-            paths = []
-            paths.push(path, path.gsub(%r{^/}, './'), path.gsub(%r{^\./}, '/')) unless path.blank?
-            paths.push('/usr/local/etc/sphinx.conf', './sphinx.conf')
-            paths.map!{|path| Pathname.new(path).expand_path}
-
-            @config = paths.find{|path| path.readable? && `#{indexer_bin} --config #{path}` !~ /fatal|error/i}
-            @config ? ConfigParser.parse(@config) : {}
-          end
-      end # Config
-    end # Sphinx
-  end # Adapters
-end # DataMapper

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

@@ -1,67 +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.
-        #
-        # @param  [String] path Searches path, ./#{path}, /#{path}, /usr/local/etc/sphinx.conf, ./sphinx.conf in
-        # that order.
-        # @return [Hash]
-        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

data/test/test_config_parser.rb

@@ -1,29 +0,0 @@
-require 'test/unit'
-require 'dm-sphinx-adapter'
-
-class TestConfigParser < Test::Unit::TestCase
-  def setup
-    base    = Pathname(__FILE__).dirname.expand_path
-    @config = base / 'files' / 'sphinx.conf'
-    @log    = base / 'var' / 'sphinx.log'
-  end
-
-  def test_parse
-    assert_nothing_raised{ parse }
-    assert_raise(Errno::ENOENT){ parse('blah') }
-    assert_raise(RuntimeError){ parse(@log) }
-  end
-
-  def test_searchd
-    assert_kind_of Hash, searchd = parse
-    assert_equal 'localhost',           searchd['address']
-    assert_equal '3312',                searchd['port']
-    assert_equal 'test/var/sphinx.pid', searchd['pid_file']
-    assert_equal 'test/var/sphinx.log', searchd['log']
-  end
-
-  protected
-    def parse(config = @config)
-      DataMapper::Adapters::Sphinx::ConfigParser.parse(config)
-    end
-end # TestConfigParser

data/test/test_type_attribute.rb

@@ -1,8 +0,0 @@
-require 'dm-sphinx-adapter'
-
-class TestTypeAttribute < Test::Unit::TestCase
-  def test_initialize
-    # TODO:
-    assert true
-  end
-end

data/test/test_type_index.rb

@@ -1,8 +0,0 @@
-require 'dm-sphinx-adapter'
-
-class TestTypeIndex < Test::Unit::TestCase
-  def test_initialize
-    # TODO:
-    assert true
-  end
-end