dm-sphinx-adapter 0.4 → 0.5

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

@@ -1,22 +0,0 @@
-module DataMapper
-  class SphinxAttribute < Property
-
-    # DataMapper types supported as Sphinx attributes.
-    TYPES = [
-      TrueClass,                # sql_attr_bool
-      String,                   # sql_attr_str2ordinal
-      # DataMapper::Types::Text,
-      Float,                    # sql_attr_float
-      Integer,                  # sql_attr_uint
-      # BigDecimal,             # sql_attr_float?
-      DateTime,                 # sql_attr_timestamp
-      Date,                     # sql_attr_timestamp
-      Time,                     # sql_attr_timestamp
-      # Object,
-      # Class,
-      # DataMapper::Types::Discriminator,
-      DataMapper::Types::Serial # sql_attr_uint
-    ]
-
-  end # SphinxAttribute
-end # DataMapper

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

@@ -1,81 +0,0 @@
-require 'rubygems'
-
-gem 'riddle', '~> 0.9'
-require 'riddle'
-
-module DataMapper
-  class SphinxClient
-    def initialize(uri_or_options)
-      # TODO: Documentation.
-      @config = SphinxConfig.new(uri_or_options)
-    end
-
-    ##
-    # Search one or more indexes.
-    #
-    # @param [String] query The sphinx query string.
-    # @param [Array, String] indexes A string or array of indexes to search. Default is '*' (all).
-    # @param [Hash] options Any options you'd like to pass through to Riddle::Client.
-    # @see   Riddle::Client
-    def search(query, indexes = '*', options = {})
-      indexes = indexes.join(' ') if indexes.kind_of?(Array)
-
-      client = Riddle::Client.new(@config.address, @config.port)
-      options.each{|k, v| client.method("#{k}=".to_sym).call(v) if client.respond_to?("#{k}=".to_sym)}
-      client.query(query, indexes.to_s)
-    end
-
-    ##
-    # Index one or more indexes.
-    #
-    # @param [Array, String] indexes Defaults to --all if indexes is nil or '*'.
-    def index(indexes = nil, options = {})
-      indexes = indexes.join(' ') if indexes.kind_of?(Array)
-
-      command = @config.indexer_bin
-      command << " --rotate" if running?
-      command << ((indexes.nil? || indexes == '*') ? ' --all' : " #{indexes.to_s}")
-      warn "Sphinx: Indexer #{$1}" if `#{command}` =~ /(?:error|fatal|warning):?\s*([^\n]+)/i
-    end
-
-    protected
-
-      ##
-      # Is the client running.
-      #
-      # Tests the address and port set in the configuration file.
-      def running?
-        !!TCPSocket.new(@config.address, @config.port) rescue nil
-      end
-  end # SphinxClient
-
-  ##
-  # Managed searchd if you don't already have god/monit doing the job for you.
-  #
-  # Requires you have daemon_controller installed.
-  # @see http://github.com/FooBarWidget/daemon_controller/tree/master
-  class SphinxManagedClient < SphinxClient
-    def initialize(url_or_options)
-      super
-
-      # Fire up searchd.
-      require 'daemon_controller'
-      @client = DaemonController.new(
-        :identifier    => 'Sphinx searchd',
-        :start_command => @config.searchd_bin,
-        :stop_command  => "#{@config.searchd_bin} --stop",
-        :ping_command  => method(:running?),
-        :pid_file      => @config.pid_file,
-        :log_file      => @config.log
-      )
-    end
-
-    def search(*args)
-      @client.connect{super}
-    end
-
-    def stop
-      @client.stop
-    end
-  end # SphinxManagedClient
-end # DataMapper

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

@@ -1,160 +0,0 @@
-require 'strscan'
-require 'pathname'
-
-# TODO: Error classes.
-# TODO: Just warn if a config file can't be found.
-
-module DataMapper
-  class SphinxConfig
-
-    ##
-    # Read a sphinx configuration file.
-    #
-    # This class just gives you access to handy searchd {} configuration options. It does not validate your
-    # configuration file beyond basic syntax checking.
-    def initialize(uri_or_options = {})
-      @config  = []
-      @searchd = {
-        'address'         => '0.0.0.0',
-        'log'             => 'searchd.log',
-        'max_children'    => 0,
-        'max_matches'     => 1000,
-        'pid_file'        => nil,
-        'port'            => 3312,
-        'preopen_indexes' => 0,
-        'query_log'       => '',
-        'read_timeout'    => 5,
-        'seamless_rotate' => 1,
-        'unlink_old'      => 1
-      }
-
-      path = case uri_or_options
-        when Addressable::URI, DataObjects::URI then uri_or_options.path
-        when Hash                               then uri_or_options[:config] || uri_or_options[:database]
-        when Pathname                           then uri_or_options
-        when String                             then DataObjects::URI.parse(uri_or_options).path
-      end
-      parse('' + path.to_s) # Force stringy since Pathname#to_s is broken IMO.
-    end
-
-    ##
-    # Configuration file full path name.
-    #
-    # @return [String]
-    def config
-      @config
-    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 binardy full path name and config argument.
-    def searchd_bin(use_config = true)
-      path = 'searchd' # TODO: Real.
-      path << " --config #{config}" if config
-      path
-    end
-
-    ##
-    # Searchd address.
-    def address
-      searchd['address']
-    end
-
-    ##
-    # Searchd port.
-    def port
-      searchd['port']
-    end
-
-    ##
-    # Searchd pid_file.
-    def pid_file
-      searchd['pid_file'] or raise "Mandatory pid_file option missing from searchd configuration."
-    end
-
-    ##
-    # Searchd log file.
-    def log
-      searchd['log']
-    end
-
-    ##
-    # Searchd configuration options.
-    #
-    # @see http://www.sphinxsearch.com/doc.html#confgroup-searchd
-    def searchd
-      @searchd
-    end
-
-    protected
-
-      ##
-      # Parse a sphinx config file.
-      #
-      # @param [String] path Searches path, ./path, /path, /usr/local/etc/sphinx.conf, ./sphinx.conf in that order.
-      def parse(path = '')
-        # TODO: Three discrete things going on here, should be three subs.
-        paths = [
-          path,
-          path.gsub(%r{^/}, './'),
-          path.gsub(%r{^\./}, '/'),
-          '/usr/local/etc/sphinx.conf', # TODO: Does this one depend on where searchd/indexer is installed?
-          './sphinx.conf'
-        ]
-        paths.find do |path|
-          @config = Pathname.new(path).expand_path
-          @config.readable? && `#{indexer_bin}` !~ /fatal|error/i
-        end or raise IOError, %{No readable config file (looked in #{paths.join(', ')})}
-
-        source = config.read
-        source.gsub!(/\r\n|\r|\n/, "\n") # Everything in \n
-        source.gsub!(/\s*\\\n\s*/, ' ')  # Remove unixy line wraps.
-        @in = StringScanner.new(source)
-        blocks(blocks = [])
-        @in = nil
-
-        searchd = blocks.find{|c| c['type'] =~ /searchd/i} || {}
-        @searchd.update(searchd)
-      end
-
-    private
-
-      def blocks(out = []) #:nodoc:
-        if @in.scan(/\#[^\n]*\n/) || @in.scan(/\s+/)
-          blocks(out)
-        elsif @in.scan(/indexer|searchd|source|index/i)
-          out << group = {'type' => @in.matched}
-          if @in.matched =~ /^(?:index|source)$/i
-            @in.scan(/\s* ([\w_\-]+) (?:\s*:\s*([\w_\-]+))? \s*/x) or raise "Expected #{group[:type]} name."
-            group['name']     = @in[1]
-            group['ancestor'] = @in[2]
-          end
-          @in.scan(/\s*\{/) or raise %q{Expected '\{'.}
-          pairs(kv = {})
-          group.merge!(kv)
-          @in.scan(/\s*\}/) or raise %q{Expected '\}'.}
-          blocks(out)
-        else
-          raise "Unknown near: #{@in.peek(30)}" unless @in.eos?
-        end
-      end
-
-      def pairs(out = {}) #:nodoc:
-        if @in.scan(/\#[^\n]*\n/) || @in.scan(/\s+/)
-          pairs(out)
-        elsif @in.scan(/[\w_-]+/)
-          key = @in.matched
-          @in.scan(/\s*=/) or raise %q{Expected '='.}
-          out[key] = @in.scan(/[^\n]*\n/).strip
-          pairs(out)
-        end
-      end
-  end # SphinxConfig
-end # DataMapper

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

@@ -1,21 +0,0 @@
-module DataMapper
-  class SphinxIndex
-    include Assertions
-
-    attr_reader :model, :name, :options
-
-    def initialize(model, name, options = {})
-      assert_kind_of 'model',   model,   Model
-      assert_kind_of 'name',    name,    Symbol, String
-      assert_kind_of 'options', options, Hash
-
-      @model = model
-      @name  = name.to_sym
-      @delta = options.fetch(:delta, nil)
-    end
-
-    def delta?
-      !!@delta
-    end
-  end # SphinxIndex
-end # DataMapper

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

@@ -1,88 +0,0 @@
-module DataMapper
-  ##
-  # Declare Sphinx indexes in your resource.
-  #
-  #   model Items
-  #     include Sphinx::Resource
-  #
-  #     # .. normal properties and such for :default
-  #
-  #     repository(:search) do
-  #       # Query some_index, some_index_delta in that order.
-  #       index :some_index
-  #       index :some_index_delta, :delta => true
-  #
-  #       # Sortable by some attributes.
-  #       attribute :updated_at, DateTime  # sql_attr_timestamp
-  #       attribute :age, Integer          # sql_attr_uint
-  #       attribute :deleted, Boolean      # sql_attr_bool
-  #     end
-  #   end
-  module SphinxResource
-    def self.included(model) #:nodoc:
-      model.class_eval do
-        include DataMapper::Resource
-        extend ClassMethods
-      end
-    end
-
-    module ClassMethods
-      def self.extended(model) #:nodoc:
-        model.instance_variable_set(:@sphinx_indexes, {})
-        model.instance_variable_set(:@sphinx_attributes, {})
-      end
-
-      ##
-      # Defines a sphinx index on the resource.
-      #
-      # Indexes are naturally ordered, with delta indexes at the end of the list so that duplicate document IDs in
-      # delta indexes override your main indexes.
-      #
-      # @param [Symbol] name the name of a sphinx index to search for this resource
-      # @param [Hash(Symbol => String)] options a hash of available options
-      # @see   DataMapper::SphinxIndex
-      def index(name, options = {})
-        index   = SphinxIndex.new(self, name, options)
-        indexes = sphinx_indexes(repository_name)
-        indexes << index
-
-        # TODO: I'm such a Ruby nub. In the meantime I've gone back to my Perl roots.
-        # This is a Schwartzian transform to sort delta indexes to the bottom and natural sort by name.
-        mapped  = indexes.map{|i| [(i.delta? ? 1 : 0), i.name, i]}
-        sorted  = mapped.sort{|a, b| a[0] <=> b[0] || a[1] <=> b[1]}
-        indexes.replace(sorted.map{|i| i[2]})
-
-        index
-      end
-
-      ##
-      # List of declared sphinx indexes for this model.
-      def sphinx_indexes(repository_name = default_repository_name)
-        @sphinx_indexes[repository_name] ||= []
-      end
-
-      ##
-      # Defines a sphinx attribute on the resource.
-      #
-      # @param [Symbol] name the name of a sphinx attribute to order/restrict by for this resource
-      # @param [Class] type the type to define this attribute as
-      # @param [Hash(Symbol => String)] options a hash of available options
-      # @see   DataMapper::SphinxAttribute
-      def attribute(name, type, options = {})
-        # Attributes are just properties without a getter/setter in the model.
-        # This keeps DataMapper::Query happy when building queries.
-        attribute = SphinxAttribute.new(self, name, type, options)
-        properties(repository_name)[attribute.name] = attribute
-        attribute
-      end
-
-      ##
-      # List of declared sphinx attributes for this model.
-      def sphinx_attributes(repository_name = default_repository_name)
-        properties(repository_name).grep{|p| p.kind_of? SphinxAttribute}
-      end
-
-    end # ClassMethods
-  end # SphinxResource
-end # DataMapper
-

data/test/helper.rb

@@ -1,7 +0,0 @@
-require 'dm-sphinx-adapter'
-require 'test/fixtures/item'
-require 'test/fixtures/item_resource_only'
-require 'test/fixtures/item_resource_explicit'
-require 'test/unit'
-
-# DataMapper::Logger.new(STDOUT, :debug)

data/test/test_search.rb

@@ -1,52 +0,0 @@
-require 'helper'
-
-
-class TestSearch < Test::Unit::TestCase
-  def setup
-    # TODO: A little too brutal for me.
-    Dir.chdir(File.join(File.dirname(__FILE__), 'fixtures')) do
-      system 'mysql -u root dm_sphinx_adapter_test < item.sql' \
-        or raise %q{Tests require the dm_sphinx_adapter_test.items table.}
-    end
-
-    @config = Pathname.new(__FILE__).dirname.expand_path / 'data' / 'sphinx.conf'
-    DataMapper.setup(:default, 'mysql://localhost/dm_sphinx_adapter_test')
-    DataMapper.setup(:search,
-      :adapter => 'sphinx',
-      :config  => @config,
-      :managed => true
-    )
-  end
-
-  def teardown
-    DataMapper.repository(:search).adapter.client.stop
-    # You can also build a new client with the same config and call stop on that.
-    # client = DataMapper::SphinxManagedClient.new(@config)
-    # client.stop
-  end
-
-  def test_search
-    assert_nothing_raised{ Item.search }
-    assert_nothing_raised{ Item.search(:name => 'foo') }
-    assert !Item.search(:name => 'foo').empty?
-  end
-
-  def test_search_resource_only
-    assert_nothing_raised{ ItemResourceOnly.search }
-    assert_nothing_raised{ ItemResourceOnly.search(:name => 'foo') }
-    assert !ItemResourceOnly.search(:name => 'foo').empty?
-  end
-
-  def test_search_resource_explicit
-    assert_nothing_raised{ ItemResourceExplicit.search }
-    assert_nothing_raised{ ItemResourceExplicit.search(:name => 'foo') }
-    assert !ItemResourceExplicit.search(:name => 'foo').empty?
-  end
-
-  def test_search_attributes
-    # Attributes that exist only in :search and the sphinx.
-    assert_nothing_raised do
-      ItemResourceExplicit.search(:updated => (Time.now - 10 .. Time.now + 10))
-    end
-  end
-end # TestSearch