dm-sphinx-adapter 0.4 → 0.5

data/test/test_config.rb

@@ -1,41 +1,75 @@
-require 'helper'
+require 'test/unit'
+require 'dm-sphinx-adapter'
 
 class TestConfig < Test::Unit::TestCase
   def setup
-    data    = Pathname(__FILE__).dirname.expand_path / 'data'
-    @config = data / 'sphinx.conf'
-    @log    = data / 'sphinx.log'
+    base    = Pathname(__FILE__).dirname.expand_path
+    @config = base / 'files' / 'sphinx.conf'
+    @log    = base / 'var' / 'sphinx.log'
   end
 
   def test_initialize
-    assert_nothing_raised{ config_new }
-    assert_raise(IOError){ config_new(:config => nil) }
-    assert_raise(IOError){ config_new(:config => 'blah') }
-    assert_raise(IOError){ config_new(:config => @log) }
+    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_forms
-    assert_nothing_raised{ config_new(:database => @config) }
-    # TODO: DataObjects::URI treats /test as the hostname.
-    # assert_nothing_raised{ config_new('file://test/data/sphinx.conf') }
-    assert_nothing_raised{ config_new('sphinx://localhost/test/data/sphinx.conf') }
+  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_config
-    assert_equal @config, config_new.config
+  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_searchd
-    assert_kind_of Hash,                 config_new.searchd
-    assert_equal 'localhost',            config_new.address
-    assert_equal '3312',                 config_new.port
-    assert_equal 'test/data/sphinx.pid', config_new.pid_file
-    assert_equal 'test/data/sphinx.log', config_new.log
+  def test_initialize_database_string
+    assert c = config("sphinx://localhost/test/files/sphinx.conf")
+    assert_equal @config, c.config
   end
 
   protected
-    def config_new(options = {:config => @config})
-      DataMapper::SphinxConfig.new(options)
+    def config(options = {:config => @config})
+      DataMapper::Adapters::Sphinx::Config.new(options)
     end
-
 end # TestConfig

data/test/test_config_parser.rb

@@ -0,0 +1,29 @@
+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_query.rb

@@ -0,0 +1,47 @@
+require 'test/unit'
+require 'dm-sphinx-adapter'
+require 'files/resource_explicit'
+
+class TestQuery < Test::Unit::TestCase
+  def setup
+    DataMapper.setup(:default, :adapter => 'sphinx')
+    @repository = repository(:default)
+  end
+
+  def test_initialize
+    assert_nothing_raised{ query }
+    assert_equal '', query.to_s
+  end
+
+  def test_eql
+    assert_equal '@name "foo"',     query(:name => 'foo').to_s
+    assert_equal '@name "foo"',     query(:name.eql => 'foo').to_s
+    assert_equal '@name "foo"',     query(:name.like => 'foo').to_s
+    assert_equal '@name "foo bar"', query(:name => %w(foo bar)).to_s
+  end
+
+  def test_not
+    assert_equal '@name -"foo"',     query(:name.not => 'foo').to_s
+    assert_equal '@name -"foo bar"', query(:name.not => %w(foo bar)).to_s
+  end
+
+  def test_in
+    assert_equal '@name ("foo" | "bar")', query(:name.in => %w{foo bar}).to_s
+  end
+
+  def test_and
+    # When is DM going to switch conditions to an array? :(
+    assert /(?:@name "b" )?@name "a"(?: @name "b")?/.match(query(:name.eql => 'a', :name.eql => 'b').to_s)
+  end
+
+  def test_raw
+    assert_equal '"foo bar"~10', query(:conditions => ['"foo bar"~10']).to_s
+  end
+
+  protected
+    def query(conditions = {})
+      DataMapper::Adapters::Sphinx::Query.new(
+        DataMapper::Query.new(@repository, Explicit, conditions)
+      )
+    end
+end # TestQuery

data/test/test_type_attribute.rb

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

data/test/test_type_index.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: dm-sphinx-adapter
 version: !ruby/object:Gem::Version 
-  version: "0.4"
+  version: "0.5"
 platform: ruby
 authors: 
 - Shane Hanna
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2008-11-20 00:00:00 +11:00
+date: 2008-12-01 00:00:00 +11:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -42,7 +42,7 @@ dependencies:
       - !ruby/object:Gem::Version 
         version: 1.8.2
     version: 
-description: ""
+description: A DataMapper Sphinx adapter.
 email: 
 - shane.hanna@gmail.com
 executables: []
@@ -62,23 +62,34 @@ files:
 - Rakefile
 - dm-sphinx-adapter.gemspec
 - lib/dm-sphinx-adapter.rb
-- lib/dm-sphinx-adapter/sphinx_adapter.rb
-- lib/dm-sphinx-adapter/sphinx_attribute.rb
-- lib/dm-sphinx-adapter/sphinx_client.rb
-- lib/dm-sphinx-adapter/sphinx_config.rb
-- lib/dm-sphinx-adapter/sphinx_index.rb
-- lib/dm-sphinx-adapter/sphinx_resource.rb
-- test/data/sphinx.conf
-- test/fixtures/item.rb
-- test/fixtures/item.sql
-- test/fixtures/item_resource_explicit.rb
-- test/fixtures/item_resource_only.rb
-- test/helper.rb
+- lib/dm-sphinx-adapter/adapter.rb
+- lib/dm-sphinx-adapter/attribute.rb
+- lib/dm-sphinx-adapter/client.rb
+- lib/dm-sphinx-adapter/config.rb
+- lib/dm-sphinx-adapter/config_parser.rb
+- lib/dm-sphinx-adapter/index.rb
+- lib/dm-sphinx-adapter/query.rb
+- lib/dm-sphinx-adapter/resource.rb
+- test/files/dm_sphinx_adapter_test.sql
+- test/files/resource_explicit.rb
+- test/files/resource_resource.rb
+- test/files/resource_searchable.rb
+- test/files/resource_storage_name.rb
+- test/files/resource_vanilla.rb
+- test/files/sphinx.conf
+- test/test_adapter.rb
+- test/test_adapter_explicit.rb
+- test/test_adapter_resource.rb
+- test/test_adapter_searchable.rb
+- test/test_adapter_vanilla.rb
 - test/test_client.rb
 - test/test_config.rb
-- test/test_search.rb
+- test/test_config_parser.rb
+- test/test_query.rb
+- test/test_type_attribute.rb
+- test/test_type_index.rb
 has_rdoc: true
-homepage: A Sphinx DataMapper adapter.
+homepage: http://dm-sphinx.rubyforge.org
 post_install_message: 
 rdoc_options: 
 - --main
@@ -103,8 +114,16 @@ rubyforge_project: dm-sphinx-adapter
 rubygems_version: 1.3.0
 signing_key: 
 specification_version: 2
-summary: ""
+summary: A DataMapper Sphinx adapter.
 test_files: 
+- test/test_adapter.rb
+- test/test_adapter_explicit.rb
+- test/test_adapter_resource.rb
+- test/test_adapter_searchable.rb
+- test/test_adapter_vanilla.rb
 - test/test_client.rb
 - test/test_config.rb
-- test/test_search.rb
+- test/test_config_parser.rb
+- test/test_query.rb
+- test/test_type_attribute.rb
+- test/test_type_index.rb

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

@@ -1,220 +0,0 @@
-require 'benchmark'
-
-# TODO: I think perhaps I should move all the query building code to a lib of its own.
-
-module DataMapper
-  module Adapters
-
-    # == Synopsis
-    # DataMapper uses URIs or a connection has to connect to your data-stores. In this case the sphinx search daemon
-    # <tt>searchd</tt>.
-    #
-    # On its own this adapter will only return an array of document IDs when queried. The dm-more source (not the gem)
-    # however provides dm-is-searchable, a common interface to search one adapter and load documents from another. My
-    # suggestion is to use this adapter in tandem with dm-is-searchable.
-    #
-    # The dm-is-searchable plugin is part of dm-more though unfortunately isn't built and bundled with dm-more gem.
-    # You'll need to checkout the dm-more source with Git from git://github.com/sam/dm-more.git and build/install the
-    # gem yourself.
-    #
-    #   git clone git://github.com/sam/dm-more.git
-    #   cd dm-more/dm-is-searchable
-    #   sudo rake install_gem
-    #
-    # Like all DataMapper adapters you can connect with a Hash or URI.
-    #
-    # A URI:
-    #   DataMapper.setup(:search, 'sphinx://localhost')
-    #
-    # The breakdown is:
-    #   "#{adapter}://#{host}:#{port}/#{config}"
-    #   - adapter Must be :sphinx
-    #   - host    Hostname (default: localhost)
-    #   - port    Optional port number (default: 3312)
-    #   - config  Optional but recommended path to sphinx config file.
-    #
-    # Alternatively supply a Hash:
-    #   DataMapper.setup(:search, {
-    #     :adapter  => 'sphinx',       # required
-    #     :config   => './sphinx.conf' # optional. Recommended though.
-    #     :host     => 'localhost',    # optional. Default: localhost
-    #     :port     => 3312            # optional. Default: 3312
-    #     :managed  => true            # optional. Self managed searchd server using daemon_controller.
-    #   })
-    class SphinxAdapter < AbstractAdapter
-      ##
-      # Initialize the sphinx adapter.
-      #
-      # @param [URI, DataObject::URI, Addressable::URI, String, Hash, Pathname] uri_or_options
-      # @see   DataMapper::SphinxConfig
-      # @see   DataMapper::SphinxClient
-      def initialize(name, uri_or_options)
-        super
-
-        managed = !!(uri_or_options.kind_of?(Hash) && uri_or_options[:managed])
-        @client  = managed ? SphinxManagedClient.new(uri_or_options) : SphinxClient.new(uri_or_options)
-      end
-
-      ##
-      # Interaction with searchd and indexer.
-      #
-      # @see DataMapper::SphinxClient
-      # @see DataMapper::SphinxManagedClient
-      attr_reader :client
-
-      def create(resources) #:nodoc:
-        true
-      end
-
-      def delete(query) #:nodoc:
-        true
-      end
-
-      def read_many(query)
-        read(query)
-      end
-
-      def read_one(query)
-        read(query).first
-      end
-
-      protected
-        ##
-        # List sphinx indexes to search.
-        # If no indexes are explicitly declared using DataMapper::SphinxResource then the tableized model name is used.
-        #
-        # @see DataMapper::SphinxResource#sphinx_indexes
-        def indexes(model)
-          indexes = model.sphinx_indexes(repository(self.name).name) if model.respond_to?(:sphinx_indexes)
-          if indexes.nil? or indexes.empty?
-            indexes = [SphinxIndex.new(model, model.storage_name)]
-          end
-          indexes
-        end
-
-        ##
-        # List sphinx delta indexes to search.
-        #
-        # @see DataMapper::SphinxResource#sphinx_indexes
-        def delta_indexes(model)
-          indexes(model).find_all{|i| i.delta?}
-        end
-
-        ##
-        # Query sphinx for a list of document IDs.
-        #
-        # @param [DataMapper::Query]
-        def read(query)
-          from    = indexes(query.model).map{|index| index.name}.join(', ')
-          search  = search_query(query)
-          options = {
-            :match_mode => :extended, # TODO: Modes!
-            :filters    => search_filters(query) # By attribute.
-          }
-          options[:limit]  = query.limit.to_i  if query.limit
-          options[:offset] = query.offset.to_i if query.offset
-
-          if order = search_order(query)
-            options.update(
-              :sort_mode => :extended,
-              :sort_by   => order
-            )
-          end
-
-          res = @client.search(search, from, options)
-          raise res[:error] unless res[:error].nil?
-
-          DataMapper.logger.info(
-            %q{Sphinx (%.3f): search '%s' in '%s' found %d documents} % [res[:time], search, from, res[:total]]
-          )
-          res[:matches].map{|doc| {:id => doc[:doc]}}
-        end
-
-        ##
-        # Sphinx search query string from properties (fields).
-        #
-        # If the query has no conditions an '' empty string will be generated possibly triggering Sphinx's full scan
-        # mode.
-        #
-        # @see    http://www.sphinxsearch.com/doc.html#searching
-        # @see    http://www.sphinxsearch.com/doc.html#conf-docinfo
-        # @param  [DataMapper::Query]
-        # @return [String]
-        def search_query(query)
-          match  = []
-
-          if query.conditions.empty?
-            match << ''
-          else
-            # TODO: This needs to be altered by match mode since not everything is supported in different match modes.
-            query.conditions.each do |operator, property, value|
-              next if property.kind_of? SphinxAttribute # Filters are added elsewhere.
-              # TODO: Why does my gem riddle differ from the vendor riddle that comes with ts?
-              # escaped_value = Riddle.escape(value)
-              escaped_value = value.to_s.gsub(/[\(\)\|\-!@~"&\/]/){|char| "\\#{char}"}
-              match << case operator
-                when :eql, :like then "@#{property.field} #{escaped_value}"
-                when :not        then "@#{property.field} -#{escaped_value}"
-                when :lt, :gt, :lte, :gte
-                  DataMapper.logger.warn('Sphinx: Query properties with lt, gt, lte, gte are treated as .eql')
-                  "@#{name} #{escaped_value}"
-                when :raw
-                  "#{property}"
-              end
-            end
-          end
-          match.join(' ')
-        end
-
-        ##
-        # Sphinx search query filters from attributes.
-        # @param  [DataMapper::Query]
-        # @return [Array]
-        def search_filters(query)
-          filters = []
-          query.conditions.each do |operator, attribute, value|
-            next unless attribute.kind_of? SphinxAttribute
-            # TODO: Value cast to uint, bool, str2ordinal, float
-            filters << case operator
-              when :eql, :like then Riddle::Client::Filter.new(attribute.name.to_s, filter_value(value))
-              when :not        then Riddle::Client::Filter.new(attribute.name.to_s, filter_value(value), true)
-              else
-                error = "Sphinx: Query attributes do not support the #{operator} operator"
-                DataMapper.logger.error(error)
-                raise error # TODO: RuntimeError subclass and more information about the actual query.
-            end
-          end
-          filters
-        end
-
-        ##
-        # Order by attributes.
-        #
-        # @return [String or Symbol]
-        def search_order(query)
-          by = []
-          # TODO: How do you tell the difference between the default query order and someone explicitly asking for
-          # sorting by the primary key?
-          query.order.each do |order|
-            next unless order.property.kind_of? SphinxAttribute
-            by << [order.property.field, order.direction].join(' ')
-          end
-          by.empty? ? nil : by.join(', ')
-        end
-
-        # TODO: Move this to SphinxAttribute#something.
-        # This is ninja'd straight from TS just to get things going.
-        def filter_value(value)
-          case value
-            when Range
-              value.first.is_a?(Time) ? value.first.to_i..value.last.to_i : value
-            when Array
-              value.collect { |val| val.is_a?(Time) ? val.to_i : val }
-            else
-              Array(value)
-          end
-        end
-    end # SphinxAdapter
-  end # Adapters
-end # DataMapper
-