mdwan-rsolr 0.8.2

data/lib/rsolr/http_client.rb

@@ -0,0 +1,140 @@
+# A simple wrapper for different http client implementations.
+# Supports #get and #post
+# This was motivated by: http://apocryph.org/2008/11/09/more_indepth_analysis_ruby_http_client_performance/
+# Curb is the default adapter
+
+# Each adapters response should be a hash with the following keys:
+#   :status_code
+#   :url
+#   :body
+#   :path
+#   :params
+#   :data
+#   :headers
+
+# Example:
+#   connector = RSolr::HTTPClient.Connector.new
+#   connector.adapter_name = :net_http # switch to Net::HTTP before calling "connect"
+#   hclient = connector.connect('http://www.google.com')
+#   response = hclient.get('/search', :hl=>:en, :q=>:ruby, :btnG=>:Search)
+#   puts response[:status_code]
+#   puts response[:body]
+
+require 'uri'
+
+module RSolr::HTTPClient
+  
+  autoload :Adapter, 'rsolr/http_client/adapter'
+  
+  class UnkownAdapterError < RuntimeError; end
+  
+  class Connector
+    
+    attr_accessor :adapter_name
+    
+    def initialize(adapter_name = :curb)
+      @adapter_name = adapter_name
+    end
+    
+    def connect(url)
+      case adapter_name
+      when :curb
+        klass = 'Curb'
+      when :net_http
+        klass = 'NetHTTP'
+      else
+        raise UnkownAdapterError.new("Name: #{adapter_name}")
+      end
+      begin
+        RSolr::HTTPClient::Base.new RSolr::HTTPClient::Adapter.const_get(klass).new(url)
+      rescue ::URI::InvalidURIError
+        raise "#{$!} == #{url}"
+      end
+    end
+    
+  end
+  
+  class Base
+    
+    attr_reader :adapter
+    
+    def initialize(adapter)
+      @adapter = adapter
+    end
+    
+    def get(path, params={})
+      begin
+        http_context = @adapter.get(path, params)
+      rescue
+        raise RSolr::RequestError.new($!)
+      end
+      http_context
+    end
+    
+    def post(path, data, params={}, headers={})
+      begin
+        http_context = @adapter.post(path, data, params, headers)
+      rescue
+        raise RSolr::RequestError.new($!)
+      end
+      http_context
+    end
+    
+  end
+  
+  module Util
+    
+    # escapes a query key/value for http
+    def escape(s)
+      s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/n) {
+        '%'+$1.unpack('H2'*$1.size).join('%').upcase
+      }.tr(' ', '+') 
+    end
+
+    def build_url(url='', params={}, string_query='')
+      queries = [string_query, hash_to_params(params)]
+      queries.delete_if{|i| i.to_s.empty?}
+      url += "?#{queries.join('&')}" unless queries.empty?
+      url
+    end
+
+    def build_param(k,v)
+      "#{escape(k)}=#{escape(v)}"
+    end
+
+    #
+    # converts hash into URL query string, keys get an alpha sort
+    # if a value is an array, the array values get mapped to the same key:
+    #   hash_to_params(:q=>'blah', :fq=>['blah', 'blah'], :facet=>{:field=>['location_facet', 'format_facet']})
+    # returns:
+    #   ?q=blah&fq=blah&fq=blah&facet.field=location_facet&facet.field=format.facet
+    #
+    # if a value is empty/nil etc., the key is not added
+    def hash_to_params(params)
+      return unless params.is_a?(Hash)
+      # copy params and convert keys to strings
+      params = params.inject({}){|acc,(k,v)| acc.merge({k.to_s, v}) }
+      # get sorted keys
+      params.keys.sort.inject([]) do |acc,k|
+        v = params[k]
+        if v.is_a?(Array)
+          acc << v.reject{|i|i.to_s.empty?}.collect{|vv|build_param(k, vv)}
+        elsif v.is_a?(Hash)
+          # NOT USED
+          # creates dot based params like:
+          # hash_to_params(:facet=>{:field=>['one', 'two']}) == facet.field=one&facet.field=two
+          # TODO: should this go into a non-solr based param builder?
+          #   - dotted syntax is special to solr only
+          #v.each_pair do |field,field_value|
+          #  acc.push(hash_to_params({"#{k}.#{field}"=>field_value}))
+          #end
+        elsif ! v.to_s.empty?
+          acc.push(build_param(k, v))
+        end
+        acc
+      end.join('&')
+    end
+    
+  end
+  
+end

data/lib/rsolr/http_client/adapter.rb

@@ -0,0 +1,6 @@
+module RSolr::HTTPClient::Adapter
+  
+  autoload :Curb, 'rsolr/http_client/adapter/curb'
+  autoload :NetHTTP, 'rsolr/http_client/adapter/net_http'
+  
+end

data/lib/rsolr/http_client/adapter/curb.rb

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'curb'
+
+class RSolr::HTTPClient::Adapter::Curb
+  
+  include RSolr::HTTPClient::Util
+  
+  attr :uri
+  attr :connection
+  
+  def initialize(url)
+    @uri = URI.parse(url)
+    @connection = ::Curl::Easy.new
+  end
+  
+  def get(path, params={})
+    @connection.url = _build_url(path, params)
+    @connection.multipart_form_post = false
+    @connection.perform
+    create_http_context(path, params)
+  end
+  
+  def post(path, data, params={}, headers={})
+    @connection.url = _build_url(path, params)
+    @connection.headers = headers
+    @connection.http_post(data)
+    create_http_context(path, params, data, headers)
+  end
+  
+  protected
+  
+  def create_http_context(path, params, data=nil, headers={})
+    {
+      :status_code=>@connection.response_code.to_i,
+      :url=>@connection.url,
+      :body=>@connection.body_str,
+      :path=>path,
+      :params=>params,
+      :data=>data,
+      :headers=>headers
+    }
+  end
+  
+  def _build_url(path, params={})
+    url = @uri.scheme + '://' + @uri.host
+    url += ':' + @uri.port.to_s if @uri.port
+    url += @uri.path + path
+    build_url(url, params, @uri.query) # build_url is coming from RSolr::HTTPClient::Util
+  end
+  
+end

data/lib/rsolr/http_client/adapter/net_http.rb

@@ -0,0 +1,48 @@
+require 'net/http'
+
+class RSolr::HTTPClient::Adapter::NetHTTP
+  
+  include RSolr::HTTPClient::Util
+  
+  attr :uri
+  attr :connection
+  
+  def initialize(url)
+    @uri = URI.parse(url)
+    @connection = Net::HTTP.new(@uri.host, @uri.port)
+  end
+  
+  def get(path, params={})
+    url = _build_url(path, params)
+    net_http_response = @connection.get(url)
+    create_http_context(net_http_response, url, path, params)
+  end
+  
+  def post(path, data, params={}, headers={})
+    url = _build_url(path, params)
+    net_http_response = @connection.post(url, data, headers)
+    create_http_context(net_http_response, url, path, params, data, headers)
+  end
+  
+  protected
+  
+  def create_http_context(net_http_response, url, path, params, data=nil, headers={})
+    full_url = "#{@uri.scheme}://#{@uri.host}"
+    full_url += @uri.port ? ":#{@uri.port}" : ''
+    full_url += url
+    {
+      :status_code=>net_http_response.code.to_i,
+      :url=>full_url,
+      :body=>net_http_response.body,
+      :path=>path,
+      :params=>params,
+      :data=>data,
+      :headers=>headers
+    }
+  end
+  
+  def _build_url(path, params={})
+    build_url(@uri.path + path, params, @uri.query) # build_url is coming from RSolr::HTTPClient::Util
+  end
+  
+end

data/lib/rsolr/message.rb

@@ -0,0 +1,153 @@
+# http://builder.rubyforge.org/
+require 'rubygems'
+require 'builder'
+
+# The Solr::Message class is the XML generation module for sending updates to Solr.
+
+class RSolr::Message
+  
+  # A class that represents a "doc" xml element for a solr update
+  class Document
+    
+    # "attrs" is a hash for setting the "doc" xml attributes
+    # "fields" is an array of Field objects
+    attr_accessor :attrs, :fields
+    
+    # "doc_hash" must be a Hash/Mash object
+    # If a value in the "doc_hash" is an array,
+    # a field object is created for each value...
+    def initialize(doc_hash)
+      @fields = []
+      doc_hash.each_pair do |field,values|
+        # create a new field for each value (multi-valued)
+        # put non-array values into an array
+        values = [values] unless values.is_a?(Array)
+        values.each do |v|
+          next if v.to_s.empty?
+          @fields << Field.new({:name=>field}, v)
+        end
+      end
+      @attrs={}
+    end
+    
+    # returns an array of fields that match the "name" arg
+    def fields_by_name(name)
+      @fields.select{|f|f.name==name}
+    end
+    
+    # returns the first field that matches the "name" arg
+    def field_by_name(name)
+      @fields.detect{|f|f.name==name}
+    end
+    
+  end
+  
+  # A class that represents a "doc"/"field" xml element for a solr update
+  class Field
+    
+    # "attrs" is a hash for setting the "doc" xml attributes
+    # "value" is the text value for the node
+    attr_accessor :attrs, :value
+    
+    # "attrs" must be a hash
+    # "value" should be something that responds to #_to_s
+    def initialize(attrs, value)
+      @attrs = attrs
+      @value = value
+    end
+    
+    # the value of the "name" attribute
+    def name
+      @attrs[:name]
+    end
+    
+  end
+  
+  class << self
+    
+    # shortcut method -> xml = RSolr::Message.xml
+    def xml
+      ::Builder::XmlMarkup.new
+    end
+    
+    # generates "add" xml for updating solr
+    # "data" can be a hash or an array of hashes.
+    # - each hash should be a simple key=>value pair representing a solr doc.
+    # If a value is an array, multiple fields will be created.
+    #
+    # "add_attrs" can be a hash for setting the add xml element attributes.
+    # 
+    # This method can also accept a block.
+    # The value yielded to the block is a Message::Document; for each solr doc in "data".
+    # You can set xml element attributes for each "doc" element or individual "field" elements.
+    #
+    # For example:
+    #
+    # solr.add({:id=>1, :nickname=>'Tim'}, {:boost=>5.0, :commitWithin=>1.0}) do |doc_msg|
+    #   doc_msg.attrs[:boost] = 10.00 # boost the document
+    #   nickname = doc_msg.field_by_name(:nickname)
+    #   nickname.attrs[:boost] = 20 if nickname.value=='Tim' # boost a field
+    # end
+    #
+    # would result in an add element having the attributes boost="10.0"
+    # and a commitWithin="1.0".
+    # Each doc element would have a boost="10.0".
+    # The "nickname" field would have a boost="20.0"
+    # if the doc had a "nickname" field with the value of "Tim".
+    #
+    def add(data, add_attrs={}, &blk)
+      data = [data] if data.respond_to?(:each_pair)
+      xml.add(add_attrs) do |add_node|
+        data.each do |item|
+          # create doc, passing in fields
+          doc = Document.new(item)
+          yield doc if block_given?
+          add_node.doc(doc.attrs) do |doc_node|
+            doc.fields.each do |field_obj|
+              doc_node.field(field_obj.value, field_obj.attrs)
+            end
+          end
+        end
+      end
+    end
+    
+    # generates a <commit/> message
+    def commit(opts={})
+      xml.commit(opts)
+    end
+    
+    # generates a <optimize/> message
+    def optimize(opts={})
+      xml.optimize(opts)
+    end
+    
+    # generates a <rollback/> message
+    def rollback
+      xml.rollback
+    end
+    
+    # generates a <delete><id>ID</id></delete> message
+    # "ids" can be a single value or array of values
+    def delete_by_id(ids)
+      ids = [ids] unless ids.is_a?(Array)
+      xml.delete do |xml|
+        ids.each do |id|
+          xml.id(id)
+        end
+      end
+    end
+    
+    # generates a <delete><query>ID</query></delete> message
+    # "queries" can be a single value or an array of values
+    def delete_by_query(queries)
+      queries = [queries] unless queries.is_a?(Array)
+      xml.delete do |xml|
+        queries.each do |query|
+          xml.query(query)
+        end
+      end
+    end
+    
+  end
+  
+end

data/test/connection/direct_test.rb

@@ -0,0 +1,25 @@
+if defined?(JRUBY_VERSION)
+  
+  require 'helper'
+  require 'connection/test_methods'
+  
+  class ConnectionDirectTest < RSolrBaseTest
+    
+    include ConnectionTestMethods
+    
+    def setup
+      base = File.expand_path( File.dirname(__FILE__) )
+      dist = File.join(base, '..', '..', 'apache-solr')
+      home = File.join(dist, 'example', 'solr')
+      @solr = RSolr.connect(:adapter=>:direct, :home_dir=>home, :dist_dir=>dist)
+      @solr.delete_by_query('*:*')
+      @solr.commit
+    end
+    
+    def teardown
+      @solr.adapter.close
+    end
+    
+  end
+  
+end

data/test/connection/http_test.rb

@@ -0,0 +1,18 @@
+unless defined?(JRUBY_VERSION)
+  
+  require 'helper'
+  require 'connection/test_methods'
+  
+  class AdapterHTTPTest < RSolrBaseTest
+  
+    include ConnectionTestMethods
+  
+    def setup
+      @solr = RSolr.connect
+      @solr.delete_by_query('*:*')
+      @solr.commit
+    end
+  
+  end
+  
+end