zinx 0.0.1

data/lib/sphinx/sphinx/request.rb

@@ -0,0 +1,50 @@
+module Sphinx
+  # Pack ints, floats, strings, and arrays to internal representation
+  # needed by Sphinx search engine.
+  class Request
+    # Initialize new request.
+    def initialize
+      @request = ''
+    end
+    
+    # Put int(s) to request.
+    def put_int(*ints)
+      ints.each { |i| @request << [i].pack('N') }
+    end
+
+    # Put 64-bit int(s) to request.
+    def put_int64(*ints)
+      ints.each { |i| @request << [i].pack('q').reverse }#[i >> 32, i & ((1 << 32) - 1)].pack('NN') }
+    end
+
+    # Put string(s) to request (first length, then the string itself).
+    def put_string(*strings)
+      strings.each { |s| @request << [s.length].pack('N') + s }
+    end
+    
+    # Put float(s) to request.
+    def put_float(*floats)
+      floats.each do |f|
+        t1 = [f].pack('f') # machine order
+        t2 = t1.unpack('L*').first # int in machine order
+        @request << [t2].pack('N')
+      end
+    end
+    
+    # Put array of ints to request (first length, then the array itself)
+    def put_int_array(arr)
+      put_int arr.length, *arr
+    end
+
+    # Put array of 64-bit ints to request (first length, then the array itself)
+    def put_int64_array(arr)
+      put_int arr.length
+      put_int64(*arr)
+    end
+    
+    # Returns the entire message
+    def to_s
+      @request
+    end
+  end
+end

data/lib/sphinx/sphinx/response.rb

@@ -0,0 +1,69 @@
+module Sphinx
+  # Unpack internal Sphinx representation of ints, floats, strings, and arrays.
+  # needed by Sphinx search engine.
+  class Response
+    # Initialize new request.
+    def initialize(response)
+      @response = response
+      @position = 0
+      @size = response.length
+    end
+    
+    # Gets current stream position.
+    def position
+      @position
+    end
+    
+    # Gets response size.
+    def size
+      @size
+    end
+    
+    # Returns <tt>true</tt> when response stream is out.
+    def eof?
+      @position >= @size
+    end
+
+    # Get int from stream.
+    def get_int
+      raise EOFError if @position + 4 > @size
+      value = @response[@position, 4].unpack('N*').first
+      @position += 4
+      return value
+    end
+
+    # Get 64-bit int from stream.
+    def get_int64
+      raise EOFError if @position + 8 > @size
+      hi, lo = @response[@position, 8].unpack('N*N*')
+      @position += 8
+      return (hi << 32) + lo
+    end
+
+    # Get array of <tt>count</tt> ints from stream.
+    def get_ints(count)
+      length = 4 * count
+      raise EOFError if @position + length > @size
+      values = @response[@position, length].unpack('N*' * count)
+      @position += length
+      return values
+    end
+    
+    # Get string from stream.
+    def get_string
+      length = get_int
+      raise EOFError if @position + length > @size
+      value = length > 0 ? @response[@position, length] : ''
+      @position += length
+      return value
+    end
+    
+    # Get float from stream.
+    def get_float
+      raise EOFError if @position + 4 > @size
+      uval = @response[@position, 4].unpack('N*').first;
+      @position += 4
+      return ([uval].pack('L')).unpack('f*').first
+    end
+  end
+end

data/lib/zinx.rb

@@ -0,0 +1,274 @@
+require File.dirname(__FILE__) + '/sphinx/sphinx'
+
+module Zinx
+
+	class Client < Sphinx::Client
+
+		class << self
+			attr_reader :client, # Sphinx::Client instance
+						:query, # Query text specified by the user
+						:index_name, # Index name to run the query against
+						:multiple_queries, # Boolean if needs to run more then one query (add_query)
+						:field_weights, # Hash of field weights
+						:index_weights, # Hash of index weights
+						:results # Results from Sphinx
+
+			def filter(field, value, exclude = false)
+				@client.SetFilter(field, value.instance_of?(Array) ? value : [value], exclude)
+			end
+
+			def filter_range(field, min, max, exclude = false)
+				@client.SetFilterRange(field, min, max, exclude)
+			end
+
+			def filter_float_range(field, min, max, exclude = false)
+				@client.SetFilterFloatRange(field, min, max, exclude)
+			end
+
+			def sort(mode, value = '')
+				@client.SetSortMode(mode, value)
+			end
+
+			def group(mode, value)
+				@client.SetGroupBy(value, mode)
+			end
+
+			def group_distinct(field)
+				@client.SetGroupDistinct(field)
+			end
+
+			def select(value)
+				@client.SetSelect(value)
+			end
+
+			def last_error
+				@client.GetLastError
+			end
+
+			def last_warning
+				@client.GetLastWarning
+			end
+
+			def server(host, port)
+				@client.SetServer(host, port)
+			end
+
+			def limits(offset, limit, max = 0, cutoff = 0)
+				@client.SetLimits(offset, limit, max, cutoff)
+			end
+
+			def max_query_time(time)
+				@client.SetMaxQueryTime(time)
+			end
+
+			def match_mode(mode)
+				@client.SetMatchMode(mode)
+			end
+
+			def ranking_mode(mode)
+				@client.SetRankingMode(mode)
+			end
+
+			def field_weight(field, weight)
+				@field_weights[field] = weight
+			end
+
+			def field_weights(hash)
+				@field_weights = hash
+			end
+
+			def index_weight(index, weight)
+				@index_weights[index] = weight
+			end
+
+			def index_weights(hash)
+				@index_weights = hash
+			end
+
+			def id_range(min, max)
+				@client.SetIDRange(min, max)
+			end
+
+			def geo_anchor(attr_lat, attr_lng, lat, lng)
+				@client.Set(attr_lat, attr_lng, lat, lng)
+			end
+
+			def retries(count, delay = 0)
+				@client.SetRetries(count, delay)
+			end
+
+			def override(field, type, values)
+				@client.SetOverride(field, type, values)
+			end
+
+			def reset
+				@client.ResetFilters
+				@client.ResetGroupBy
+				@client.ResetOverrides
+			end
+
+			def reset_filters
+				@client.ResetFilters
+			end
+
+			def reset_groups
+				@client.ResetGroupBy
+			end
+
+			def reset_overrides
+				@client.ResetOverrides
+			end
+
+			def build_excerpts(docs, index, words, opts = {})
+				init
+				@client.BuildExcerpts(docs, index, words, opts)
+			end
+
+			def excerpts(docs, words, opts = {})
+				run if @results.empty?
+				@client.BuildExcerpts(docs, @index_name, words, opts)
+			end
+
+			def build_keywords(query, index, hits)
+				init
+				@client.BuildKeywords(query, index, hits)
+			end
+
+			def update(index, attrs, values, mva = false)
+				init
+				@client.UpdateAttributes(index, attrs, values, mva)
+			end
+
+			def results
+				run if @results.empty?
+				@results
+			end
+
+			# syntax sugar for results[0].matches when using only one query
+			# you don't even have to call 'run' before using this
+			def matches
+				run if @results.empty?
+				!@multiple_queries && @results.count > 0 ? @results[0].matches : []
+			end
+
+			# must call run before accessing search results
+			def run
+				# set the weights
+				@client.SetFieldWeights(@field_weights) unless @field_weights.empty?
+				@client.SetIndexWeights(@index_weights) unless @index_weights.empty?
+
+				# run the query
+				if @multiple_queries
+					q = @client.RunQueries
+					q.each do |result|
+						@results << Result.new(result)
+					end
+				else
+					q = @client.Query(@query, @index_name)
+					@results << Result.new(q)
+				end
+			end
+
+			# add query for multiple queries
+			def add_query
+				@multiple_queries = true
+				@client.AddQuery(@query, @index_name)
+				reset
+			end
+
+			# Entry point for searches
+			# Valid params are:
+			# 	:server => Sphinx server address (defaults to 'localhost')
+			#   :port => Sphinx port number (defaults to 9312)
+			#   :match_mode => Sphinx matching mode (defaults to Zinx::SPH_MATCH_EXTENDED)
+			#   :index_name => Name of the index to search on
+			def search(query, params = {}, &block)
+				params[:query] = query
+				init(params)
+				if !block_given?
+					run
+					return @results
+				else
+					yield
+				end
+			end
+
+			def init(params = {})
+				@client = Client.new
+				@client.SetServer(params[:server] || 'localhost', params[:port] || 9312)
+				@client.SetMatchMode(params[:match_mode] || Zinx::Client::SPH_MATCH_EXTENDED)
+				@query = params[:query]
+				@index_name = params[:index_name] || "*"
+				@multiple_queries = false
+				@results = []
+				@field_weights = {}
+				@index_weights = {}
+			end
+		end
+	end
+
+	class Match
+		def initialize(hash)
+			@match = hash
+		end
+
+		def each(&block)
+			@match.each do |m|
+				block.call m
+			end
+		end
+
+		def method_missing(method)
+			if ['groupby', 'count', 'expr'].include?("#{method}")
+				@match["attrs"]["@#{method}"]
+			elsif ['id', 'weight', 'attrs'].include?("#{method}")
+				@match["#{method}"]
+			else
+				@match["attrs"]["#{method}"]
+			end
+		end
+	end
+
+	class Result
+		attr_reader :matches
+
+		def initialize(sphinx_hash)
+			@matches = []
+			@sphinx_hash = sphinx_hash
+			@sphinx_hash["matches"].each do |match|
+				@matches << Match.new(match)
+			end
+		end
+
+		def method_missing(method)
+			@sphinx_hash["#{method}"]
+		end
+	end
+
+	module Search
+		class << self
+			attr_accessor :target
+
+			def delegate(*methods)
+				methods.each do |method|
+					define_method(method) do |*args, &block|
+						Search.target.send(method, *args, &block)
+					end
+					private method
+				end
+			end
+		end
+
+		self.target = Zinx::Client
+
+		delegate :filter, :filter_range, :filter_float_range, :sort, :group, :group_distinct,
+			:select, :last_error, :last_warning, :server, :limits, :max_query_time, :match_mode,
+			:ranking_mode, :field_weight, :field_weights, :index_weight, :index_weights,
+			:id_range, :geo_anchor, :retries, :override, :reset, :reset_filter, :reset_groups,
+			:reset_overrides, :build_excerpts, :excerpts, :build_keywords, :update, :results,
+			:matches, :run, :add_query, :search, :init
+	end
+
+end
+
+extend Zinx::Search

data/test/test.rb

@@ -0,0 +1,10 @@
+require 'test/unit'
+require 'zinx'
+
+class ZinxTest < Test::Unit::TestCase
+	def test_simple_search
+		result = Zinx::Client.search 'something'
+		assert result.count > 0, 'nothing returned from search'
+		assert_equal result.first.error, ''
+	end
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: zinx
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Gabriel Hora
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-03-15 00:00:00.000000000 Z
+dependencies: []
+description: Simple DSL for Sphinx Search Server
+email: gabrielhora@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/sphinx/sphinx/client.rb
+- lib/sphinx/sphinx/request.rb
+- lib/sphinx/sphinx/response.rb
+- lib/sphinx/sphinx.rb
+- lib/zinx.rb
+- test/test.rb
+homepage: http://www.polyglotdba.com/zinx
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.17
+signing_key: 
+specification_version: 3
+summary: Simple DSL for Sphinx Search Server
+test_files:
+- test/test.rb