dm-sphinx-adapter 0.4 → 0.5

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

@@ -0,0 +1,38 @@
+module DataMapper
+  module Adapters
+    module Sphinx
+
+      # Sphinx attribute definition.
+      #
+      # Supports only a subset of DataMapper::Property types that can be used as Sphinx attributes.
+      #
+      # TrueClass::                 sql_attr_bool
+      # String::                    sql_attr_str2ordinal
+      # Float::                     sql_attr_float
+      # Integer::                   sql_attr_uint
+      # DateTime::                  sql_attr_timestamp
+      # Date::                      sql_attr_timestamp
+      # DataMapper::Types::Serial:: sql_attr_uint
+      class Attribute < 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 # Attribute
+    end # Sphinx
+  end # Adapters
+end # DataMapper

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

@@ -0,0 +1,109 @@
+require 'rubygems'
+
+gem 'riddle', '~> 0.9'
+require 'riddle'
+
+module DataMapper
+  module Adapters
+    module Sphinx
+      # Client wrapper for Riddle::Client.
+      #
+      # * Simple interface to +searchd+ *and* +indexer+.
+      # * Can read +searchd+ configuration options from your sphinx configuration file.
+      # * Managed +searchd+ using +daemon_controller+ for on demand daemon control in development.
+      class Client
+
+        # ==== Parameters
+        # uri_or_options<URI, DataObject::URI, Addressable::URI, String, Hash, Pathname>::
+        #   DataMapper uri or options hash.
+        def initialize(uri_or_options = {})
+          @config = Sphinx::Config.new(uri_or_options)
+        end
+
+        # Search one or more indexes.
+        #
+        # ==== See
+        # * Riddle::Client
+        #
+        # ==== Parameters
+        # query<String>:: A sphinx query string.
+        # indexes<Array, String>:: Indexes to search. Default is '*' all.
+        # options<Hash>:: Any attributes supported by the Riddle::Client.
+        #
+        # ==== Returns
+        # Hash:: Riddle::Client#query response struct.
+        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.
+        #
+        # ==== Parameters
+        # indexes<Array, String>:: Indexes to index (and rotate). Defaults to --all if indexes is +nil+ or '*'.
+        def index(indexes = nil)
+          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 a +searchd+ daemon running on the configured address and port.
+          #
+          # ==== Notes
+          # This is a simple TCPSocket test. It may not be your +searchd+ deamon or even a +searchd+ daemon at all if
+          # your configuration is wrong or another +searchd+ daemon is listen on that port already.
+          #
+          # ==== Returns
+          # Boolean
+          def running?
+            !!TCPSocket.new(@config.address, @config.port) rescue nil
+          end
+      end # Client
+
+      # 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 ManagedClient < Client
+
+        # ==== See
+        # * DataMapper::Adapters::Sphinx::Client#new
+        def initialize(url_or_options = {})
+          super
+
+          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
+
+        # Start the +searchd+ daemon if it isn't already running then search.
+        #
+        # ==== See
+        # * DataMapper::Adapters::Sphinx::Client#search
+        def search(*args)
+          @client.connect{super}
+        end
+
+        # Stop the +searchd+ daemon if it's running.
+        def stop
+          @client.stop if @client.running?
+        end
+      end # ManagedClient
+    end # Sphinx
+  end # Adapters
+end # DataMapper

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

@@ -0,0 +1,122 @@
+require 'rubygems'
+
+gem 'extlib', '~> 0.9.7'
+require 'extlib'
+
+module DataMapper
+  module Adapters
+    module Sphinx
+      class Config
+        include Extlib::Assertions
+
+        # Configuration option.
+        attr_reader :config, :address, :log, :port
+
+        # Sphinx configuration options.
+        #
+        # This class just gives you access to handy searchd {} configuration options. If a sphinx configuration file
+        # is passed and can be parsed +searchd+ options will be set straight from the file.
+        #
+        # ==== Notes
+        # Option precedence is:
+        # * The options hash.
+        # * The configuration file.
+        # * Sphinx defaults.
+        #
+        # ==== See
+        # http://www.sphinxsearch.com/doc.html#confgroup-searchd
+        #
+        # ==== Parameters
+        # uri_or_options<URI, DataObject::URI, Addressable::URI, String, Hash, Pathname>::
+        #   DataMapper uri or options hash.
+        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.
+        #
+        # ==== Parameters
+        # use_config<Boolean>:: Return <tt>--config path/to/config.conf</tt> as part of string. Default +true+.
+        #
+        # ==== Returns
+        # String
+        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.
+        #
+        # ==== Parameters
+        # use_config<Boolean>:: Return <tt>--config path/to/config.conf</tt> as part of string. Default +true+.
+        #
+        # ==== Returns
+        # String
+        def searchd_bin(use_config = true)
+          path = 'searchd' # TODO: Real.
+          path << " --config #{config}" if config
+          path
+        end
+
+        # Full path to pid_file.
+        #
+        # ==== Raises
+        # RuntimeError:: If a pid file was not read or set. pid_file is a mandatory searchd option in a sphinx
+        #   configuration file.
+        def pid_file
+          @pid_file or raise "Mandatory pid_file option missing from searchd configuration."
+        end
+
+        protected
+          # Coerce +uri_or_options+ into a +Hash+ of options.
+          #
+          # ==== Parameters
+          # uri_or_options<URI, DataObject::URI, Addressable::URI, String, Hash, Pathname>::
+          #   DataMapper uri or options hash.
+          #
+          # ==== Returns
+          # Hash
+          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
+
+          # Reads your sphinx configuration file if given.
+          #
+          # Also searches default sphinx configuration locations for a config file to parse.
+          #
+          # ==== See
+          # * DataMapper::Adapters::Sphinx::ConfigParser
+          #
+          # ==== Parameters
+          # path<String>:: Path to your configuration file.
+          #
+          # ==== Returns
+          # Hash
+          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

@@ -0,0 +1,71 @@
+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/lib/dm-sphinx-adapter/index.rb

@@ -0,0 +1,38 @@
+module DataMapper
+  module Adapters
+    module Sphinx
+
+      # Sphinx index definition.
+      class Index
+        include Assertions
+
+        # Options.
+        attr_reader :model, :name, :options
+
+        # ==== Parameters
+        # model<DataMapper::Model>:: Your resources model.
+        # name<Symbol, String>:: The index name.
+        # options<Hash>:: Optional arguments.
+        #
+        # ==== Options
+        # :delta<Boolean>::
+        #   Delta index. Delta indexes will be searched last when multiple indexes are defined for a
+        #   resource. Default is false.
+        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, false)
+        end
+
+        # Is the index a delta index.
+        def delta?
+          !!@delta
+        end
+      end # Index
+    end # Sphinx
+  end # Adapters
+end # DataMapper

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

@@ -0,0 +1,67 @@
+module DataMapper
+  module Adapters
+    module Sphinx
+
+      # Sphinx extended search query string from DataMapper query.
+      class Query
+        include Extlib::Assertions
+
+        # Initialize a new extended Sphinx query from a DataMapper::Query object.
+        #
+        # 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
+        # * http://www.sphinxsearch.com/doc.html#conf-docinfo
+        # * http://www.sphinxsearch.com/doc.html#extended-syntax
+        #
+        # ==== Raises
+        # NotImplementedError:: DataMapper operators that can't be expressed in the extended sphinx query syntax.
+        #
+        # ==== Parameters
+        # query<DataMapper::Query>:: DataMapper query object.
+        def initialize(query)
+          assert_kind_of 'query', query, DataMapper::Query
+          @query  = []
+
+          if query.conditions.empty?
+            @query << ''
+          else
+            query.conditions.each do |operator, property, value|
+              next if property.kind_of? Sphinx::Attribute # Filters are added elsewhere.
+              normalized = normalize_value(value)
+              @query << case operator
+                when :eql, :like then '@%s "%s"'  % [property.field.to_s, normalized.join(' ')]
+                when :not        then '@%s -"%s"' % [property.field.to_s, normalized.join(' ')]
+                when :in         then '@%s (%s)'  % [property.field.to_s, normalized.map{|v| %{"#{v}"}}.join(' | ')]
+                when :raw        then "#{property}"
+                else raise NotImplementedError.new("Sphinx: Query fields do not support the #{operator} operator")
+              end
+            end
+          end
+        end
+
+        # ==== Returns
+        # String:: The extended sphinx query string.
+        def to_s
+          @query.join(' ')
+        end
+
+        protected
+          # Normalize and escape DataMapper query value(s) to escaped sphinx query values.
+          #
+          # ==== Parameters
+          # value<String, Array>:: The query value.
+          #
+          # ==== Returns
+          # Array:: An array of one or more query values.
+          def normalize_value(value)
+            [value].flatten.map do |v|
+              v.to_s.gsub(/[\(\)\|\-!@~"&\/]/){|char| "\\#{char}"}
+            end
+          end
+      end # Query
+    end # Sphinx
+  end # Adapters
+end # DataMapper