mwmitchell-solr 0.5.3 → 0.5.4

data/lib/solr/connection.rb

@@ -2,6 +2,6 @@ module Solr::Connection
   
   autoload :Base, 'solr/connection/base'
   autoload :SearchExt, 'solr/connection/search_ext'
-  autoload :PaginationExt, 'solr/connection/pagination_ext'
+  autoload :Adapter, 'solr/connection/adapter'
   
 end

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

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'curb'
+
+class Solr::HTTPClient::Adapter::Curb
+  
+  include Solr::HTTPClient::Util
+  
+  attr :uri
+  attr :c
+  
+  def initialize(url)
+    @uri = URI.parse(url)
+    @c = ::Curl::Easy.new
+  end
+  
+  def get(path, params={})
+    @c.url = _build_url(path, params)
+    @c.multipart_form_post = false
+    @c.perform
+    create_http_context(path, params)
+  end
+  
+  def post(path, data, params={}, headers={})
+    @c.url = _build_url(path, params)
+    @c.headers = headers
+    @c.http_post(data)
+    create_http_context(path, params, data, headers)
+  end
+  
+  protected
+  
+  def create_http_context(path, params, data=nil, headers={})
+    {
+      :status_code=>@c.response_code.to_i,
+      :url=>@c.url,
+      :body=>@c.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)
+  end
+  
+end

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

@@ -0,0 +1,48 @@
+require 'net/http'
+
+class Solr::HTTPClient::Adapter::NetHTTP
+  
+  include Solr::HTTPClient::Util
+  
+  attr :uri
+  attr :c
+  
+  def initialize(url)
+    @uri = URI.parse(url)
+    @c = Net::HTTP.new(@uri.host, @uri.port)
+  end
+  
+  def get(path, params={})
+    url = _build_url(path, params)
+    net_http_response = @c.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 = @c.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,
+      :body=>net_http_response.body,
+      :url=>full_url,
+      :path=>path,
+      :params=>params,
+      :data=>data,
+      :headers=>headers
+    }
+  end
+  
+  def _build_url(path, params={})
+    build_url(@uri.path + path, params, @uri.query)
+  end
+  
+end

data/lib/solr/http_client/adapter.rb

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

data/lib/solr/http_client.rb

@@ -0,0 +1,115 @@
+require 'uri'
+
+# A simple wrapper for different http client implementations
+# that supports #get and #post
+# This was motivated by: http://apocryph.org/2008/11/09/more_indepth_analysis_ruby_http_client_performance/
+# Net::HTTP is the default adapter
+
+# Each adapter response should be a hash with the following keys:
+#   :status_code
+#   :url
+#   :body
+#   :path
+#   :params
+#   :data
+#   :headers
+
+# Example:
+#hclient = Solr::HTTPClient.connect('http://www.google.com', :net_http)
+#response = hclient.get('/search', :hl=>:en, :q=>:ruby, :btnG=>:Search)
+#puts response[:status_code]
+#puts response[:body]
+
+module Solr::HTTPClient
+  
+  autoload :Adapter, 'solr/http_client/adapter'
+  
+  class UnkownAdapterError < RuntimeError; end
+  
+  def self.connect(url, adapter_name=:net_http)
+    case adapter_name
+    when :curb
+      klass = 'Curb'
+    when :net_http
+      klass = 'NetHTTP'
+    else
+      raise UnkownAdapterError.new("Name: #{adapter_name}")
+    end
+    Base.new Solr::HTTPClient::Adapter.const_get(klass).new(url)
+  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 Solr::RequestError.new($!)
+      end
+      http_context
+    end
+    
+    def post(path, data, params={}, headers={})
+      begin
+        http_context = @adapter.post(path, data, params, headers)
+      rescue
+        raise Solr::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', 'facet.field'=>['location_facet', 'format_facet'])
+    # returns:
+    #   ?q=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.to_s.empty?
+          acc.push(build_param(k, v))
+        end
+        acc
+      end.join('&')
+    end
+    
+  end
+  
+end

data/lib/solr/mapper/rss.rb

@@ -1,3 +1,5 @@
+#TODO - this could use the http wrapper stuff instead of open-uri/net::http
+
 require 'rss'
 require 'open-uri'
 

data/lib/solr/message.rb

@@ -3,6 +3,8 @@
 require 'rubygems'
 require 'builder'
 
+# The Solr::Message class is the XML generation module for sending updates to Solr.
+
 class Solr::Message
   
   class << self
@@ -27,7 +29,9 @@ class Solr::Message
             sorted_items.keys.sort.each do |k|
               doc_attrs = {:name=>k}
               yield doc_attrs if block_given?
-              doc_xml.field(sorted_items[k], doc_attrs)
+              [sorted_items[k]].flatten.each do |v| # multiValued attributes
+                doc_xml.field(v, doc_attrs)
+              end
             end
           end
         end

data/lib/solr/response/base.rb

@@ -0,0 +1,32 @@
+# default/base response object
+# This is where the ruby "eval" happens
+# So far, all response classes extend this
+class Solr::Response::Base
+  
+  attr_reader :source
+  
+  attr_reader :raw_response, :data, :header, :params, :status, :query_time
+  
+  def initialize(data)
+    if data.is_a?(Hash) and data.has_key?(:body)
+      @data = Kernel.eval(data[:body])
+      @source = data
+    else
+      if data.is_a?(String)
+        @raw_response = data
+        @data = Kernel.eval(@raw_response)
+      elsif data.is_a?(Hash)
+        @data = data
+      end
+    end
+    @header = @data['responseHeader']
+    @params = @header['params']
+    @status = @header['status']
+    @query_time = @header['QTime']
+  end
+  
+  def ok?
+    self.status==0
+  end
+  
+end

data/lib/solr/response/index_info.rb

@@ -0,0 +1,22 @@
+# response for /admin/luke
+class Solr::Response::IndexInfo < Solr::Response::Base
+  
+  attr_reader :index, :directory, :has_deletions, :optimized, :current, :max_doc, :num_docs, :version
+  
+  alias :has_deletions? :has_deletions
+  alias :optimized? :optimized
+  alias :current? :current
+  
+  def initialize(data)
+    super(data)
+    @index = @data['index']
+    @directory = @data['directory']
+    @has_deletions = @index['hasDeletions']
+    @optimized = @index['optimized']
+    @current = @index['current']
+    @max_doc = @index['maxDoc']
+    @num_docs = @index['numDocs']
+    @version = @index['version']
+  end
+  
+end

data/lib/solr/response/query.rb

@@ -0,0 +1,93 @@
+# response module for queries
+module Solr::Response::Query
+  
+  # module for adding some helper methods for each document
+  module DocExt
+    
+    # Provide "method accessors" to the data.
+    # This might be better implemented using instance_eval
+    # to create the methods?
+    def method_missing(k, *args)
+      has_key?(k) ? self[k] : super(k, *args)
+    end
+    
+    # Helper method to check if value/values exist for a given key.
+    # The value can be a string, or a RegExp
+    # Example:
+    # doc.has?(:location_facet, 'Clemons')
+    # doc.has?(:id, 'h009', /^u/i)
+    def has?(k, *values)
+      return if self[k].nil?
+      target = self[k]
+      if target.is_a?(Array)
+        values.each do |val|
+          return target.any?{|tv| val.is_a?(Regexp) ? (tv =~ val) : (tv==val)}
+        end
+      else
+        return values.any? {|val| val.is_a?(Regexp) ? (target =~ val) : (target == val)}
+      end
+    end
+
+  end
+  
+  module Pagination
+    
+    # alias to the Solr param, 'rows'
+    def per_page
+      @per_page = params['rows'].to_s.to_i
+    end
+    
+    # Returns the current page calculated from 'rows' and 'start'
+    # WillPaginate hook
+    def current_page
+      @current_page = self.per_page > 0 ? ((self.start / self.per_page).ceil) : 1
+      @current_page == 0 ? 1 : @current_page
+    end
+    
+    # Calcuates the total pages from 'numFound' and 'rows'
+    # WillPaginate hook
+    def total_pages
+      self.per_page > 0 ? (self.total / self.per_page.to_f).ceil : 1
+    end
+    
+    # returns the previous page number or 1
+    # WillPaginate hook
+    def previous_page
+      (current_page > 1) ? current_page - 1 : 1
+    end
+    
+    # returns the next page number or the last
+    # WillPaginate hook
+    def next_page
+      (current_page < total_pages) ? current_page + 1 : total_pages
+    end
+    
+  end
+  
+  # The base query response class
+  # adds to the Solr::Response::Base class by defining a few more attributes,
+  # includes the Pagination module, and extends each of the doc hashes
+  # with Solr::Response::Query::DocExt
+  class Base < Solr::Response::Base
+    
+    include Solr::Response::Query::Pagination
+    
+    attr_reader :response, :docs, :num_found, :start
+  
+    alias :total :num_found
+    alias :offset :start
+  
+    def initialize(data)
+      super(data)
+      @response = @data['response']
+      @docs = @response['docs']
+      @docs.each do |d|
+        d.extend Solr::Response::Query::DocExt
+      end
+      @num_found = @response['numFound']
+      @start = @response['start']
+    end
+  
+  end
+  
+end

data/lib/solr/response/update.rb

@@ -0,0 +1,4 @@
+# response class for update requests - not sure if this is needed yet?
+class Solr::Response::Update < Solr::Response::Base
+  
+end

data/lib/solr.rb

@@ -7,15 +7,15 @@ proc {|base, files|
 
 module Solr
   
-  VERSION = '0.5.3'
+  VERSION = '0.5.4'
   
-  autoload :Adapter, 'solr/adapter'
   autoload :Message, 'solr/message'
   autoload :Response, 'solr/response'
   autoload :Connection, 'solr/connection'
   autoload :Ext, 'solr/ext'
   autoload :Mapper, 'solr/mapper'
   autoload :Indexer, 'solr/indexer'
+  autoload :HTTPClient, 'solr/http_client'
   
   # factory for creating connections
   # adapter name is either :http or :direct
@@ -26,8 +26,7 @@ module Solr
       :http=>'HTTP',
       :direct=>'Direct'
     }
-    adapter_class_name = "Solr::Adapter::#{types[adapter_name]}"
-    adapter_class = Kernel.eval adapter_class_name
+    adapter_class = Solr::Connection::Adapter.const_get(types[adapter_name])
     Solr::Connection::Base.new(adapter_class.new(opts), opts)
   end