rsolr 0.9.6

data/examples/direct.rb

@@ -0,0 +1,29 @@
+# Must be executed using jruby
+require File.join(File.dirname(__FILE__), '..', 'lib', 'rsolr')
+
+base = File.expand_path( File.dirname(__FILE__) )
+dist = File.join(base, '..', 'apache-solr')
+home = File.join(dist, 'example', 'solr')
+
+solr = RSolr.connect(:direct, :home_dir=>home, :dist_dir=>dist)
+
+Dir['../apache-solr/example/exampledocs/*.xml'].each do |xml_file|
+  puts "Updating with #{xml_file}"
+  solr.update File.read(xml_file)
+end
+
+solr.commit
+
+puts
+
+response = solr.select :q=>'ipod', :fq=>'price:[0 TO 50]', :rows=>2, :start=>0
+
+docs = response['response']['docs']
+
+docs.each do |doc|
+  puts doc['timestamp']
+end
+
+solr.delete_by_query('*:*') and solr.commit
+
+solr.adapter.close

data/examples/http.rb

@@ -0,0 +1,25 @@
+require File.join(File.dirname(__FILE__), '..', 'lib', 'rsolr')
+
+# switch out the http adapter from net_http to curb
+solr = RSolr.connect :adapter=>:curb
+
+Dir['../apache-solr/example/exampledocs/*.xml'].each do |xml_file|
+  puts "Updating with #{xml_file}"
+  solr.update File.read(xml_file)
+end
+
+solr.commit
+
+puts
+
+response = solr.select(:q=>'ipod', :fq=>['price:[0 TO 50]'], :rows=>2, :start=>0)
+
+puts "URL : #{response.adapter_response[:url]} -> #{response.adapter_response[:status_code]}"
+
+puts
+
+response['response']['docs'].each do |doc|
+  puts doc['timestamp']
+end
+
+solr.delete_by_query('*:*') and solr.commit

data/lib/rsolr.rb

@@ -0,0 +1,66 @@
+# add this directory to the load path if it hasn't already been added
+
+require 'rubygems'
+
+$: << File.dirname(__FILE__) unless $:.include?(File.dirname(__FILE__))
+
+module RSolr
+  
+  VERSION = '0.9.5'
+  
+  autoload :Message, 'rsolr/message'
+  autoload :Connection, 'rsolr/connection'
+  autoload :HTTPClient, 'rsolr/http_client'
+  
+  # Factory for creating connections.
+  # 2 modes of argument operations:
+  #   1. first argument is solr-adapter type, second arg is options hash for solr-adapter instance.
+  #   2. options hash for solr-adapter only (no adapter type as first arg)
+  #
+  # Examples:
+  # # default http connection
+  # RSolr.connect
+  # # http connection with custom url
+  # RSolr.connect :url=>'http://solr.web100.org'
+  # # direct connection
+  # RSolr.connect :direct, :home_dir=>'solr', :dist_dir=>'solr-nightly'
+  def self.connect(*args)
+    type = args.first.is_a?(Symbol) ? args.shift : :http
+    opts = args
+    type_class = case type
+      when :http,nil
+        'HTTP'
+      when :direct
+        'Direct'
+      else
+        raise "Invalid connection type: #{type} - use :http, :direct or leave nil for :http/default"
+      end
+    adapter_class = RSolr::Connection::Adapter.const_get(type_class)
+    adapter = adapter_class.new(*opts)
+    RSolr::Connection::Base.new(adapter)
+  end
+  
+  # A module that contains string related methods
+  module Char
+    
+    # escape - from the solr-ruby library
+    # RSolr.escape('asdf')
+    # backslash everything that isn't a word character
+    def escape(value)
+      value.gsub(/(\W)/, '\\\\\1')
+    end
+    
+  end
+  
+  # send the escape method into the Connection class ->
+  # solr = RSolr.connect
+  # solr.escape('asdf')
+  RSolr::Connection::Base.send(:include, Char)
+  
+  # bring escape into this module (RSolr) -> RSolr.escape('asdf')
+  extend Char
+  
+  # RequestError is a common/generic exception class used by the adapters
+  class RequestError < RuntimeError; end
+  
+end

data/lib/rsolr/connection.rb

@@ -0,0 +1,124 @@
+module RSolr::Connection
+  
+  module Adapter
+    autoload :Direct, 'rsolr/connection/adapter/direct'
+    autoload :HTTP, 'rsolr/connection/adapter/http'
+  end
+  
+  class Base
+    
+    attr_reader :adapter
+    
+    # "adapter" is instance of:
+    #   RSolr::Adapter::HTTP
+    #   RSolr::Adapter::Direct (jRuby only)
+    # or any other class that uses the connection "interface"
+    def initialize(adapter)
+      @adapter = adapter
+    end
+  
+    # Send a request to a request handler using the method name.
+    def method_missing(method_name, *args, &blk)
+      request("/#{method_name}", *args, &blk)
+    end
+    
+    # sends data to the update handler
+    # data can be a string of xml, or an object that returns xml from its #to_xml method
+    def update(data, params={})
+      request '/update', params, data
+    end
+    
+    # send request solr
+    # params is hash with valid solr request params (:q, :fl, :qf etc..)
+    #   if params[:wt] is not set, the default is :ruby
+    #   if :wt is something other than :ruby, the raw response body is used
+    #   otherwise, a simple Hash is returned
+    #   NOTE: to get raw ruby, use :wt=>'ruby' <- a string, not a symbol like :ruby  
+    #
+    #
+    def request(path, params={}, *extra)
+      response = @adapter.request(path, map_params(params), *extra)
+      adapt_response(response)
+    end
+    
+    # 
+    # single record:
+    # solr.update(:id=>1, :name=>'one')
+    #
+    # update using an array
+    # solr.update([{:id=>1, :name=>'one'}, {:id=>2, :name=>'two'}])
+    #
+    def add(doc, &block)
+      update message.add(doc, &block)
+    end
+  
+    # send </commit>
+    def commit
+      update message.commit
+    end
+  
+    # send </optimize>
+    def optimize
+      update message.optimize
+    end
+  
+    # send </rollback>
+    # NOTE: solr 1.4 only
+    def rollback
+      update message.rollback
+    end
+  
+    # Delete one or many documents by id
+    #   solr.delete_by_id 10
+    #   solr.delete_by_id([12, 41, 199])
+    def delete_by_id(id)
+      update message.delete_by_id(id)
+    end
+  
+    # delete one or many documents by query
+    #   solr.delete_by_query 'available:0'
+    #   solr.delete_by_query ['quantity:0', 'manu:"FQ"']
+    def delete_by_query(query)
+      update message.delete_by_query(query)
+    end
+    
+    # shortcut to RSolr::Message::Builder
+    def message
+      @message ||= RSolr::Message::Builder.new
+    end
+    
+    protected
+    
+    # sets default params etc.. - could be used as a mapping hook
+    # type of request should be passed in here? -> map_params(:query, {})
+    def map_params(params)
+      params||={}
+      {:wt=>:ruby}.merge(params)
+    end
+  
+    # "adapter_response" must be a hash with the following keys:
+    #   :params - a sub hash of standard solr params
+    #   : body - the raw response body from the solr server
+    # This method will evaluate the :body value if the params[:wt] == :ruby
+    # otherwise, the body is returned
+    # The return object has a special method attached called #adapter_response
+    # This method gives you access to the original response from the adapter,
+    # so you can access things like the actual :url sent to solr,
+    # the raw :body, original :params and original :data
+    def adapt_response(adapter_response)
+      data = adapter_response[:body]
+      # if the wt is :ruby, evaluate the ruby string response
+      if adapter_response[:params][:wt] == :ruby
+        data = Kernel.eval(data)
+      end
+      # attach a method called #adapter_response that returns the original adapter response value
+      def data.adapter_response
+        @adapter_response
+      end
+      data.send(:instance_variable_set, '@adapter_response', adapter_response)
+      data
+    end
+    
+  end
+  
+end

data/lib/rsolr/connection/adapter/direct.rb

@@ -0,0 +1,88 @@
+raise "JRuby Required" unless defined?(JRUBY_VERSION)
+
+require 'java'
+
+#
+# Connection for JRuby + DirectSolrConnection
+#
+class RSolr::Connection::Adapter::Direct
+  
+  include RSolr::HTTPClient::Util
+  
+  attr_accessor :opts
+  
+  # opts can be an instance of org.apache.solr.servlet.DirectSolrConnection
+  # if opts is NOT an instance of org.apache.solr.servlet.DirectSolrConnection
+  # then...
+  # required: opts[:home_dir] is absolute path to solr home (the directory with "data", "config" etc.)
+  # opts must also contain either
+  #   :dist_dir => 'absolute path to solr distribution root
+  # or
+  #   :jar_paths => ['array of directories containing the solr lib/jars']
+  # OTHER OPTS:
+  #   :select_path => 'the/select/handler'
+  #   :update_path => 'the/update/handler'
+  def initialize(opts, &block)
+    if defined?(Java::OrgApacheSolrCore::SolrCore) and opts.is_a?(Java::OrgApacheSolrCore::SolrCore)
+      @connection = org.apache.solr.servlet.DirectSolrConnection.new(opts)
+    elsif defined?(Java::OrgApacheSolrServlet::DirectSolrConnection) and opts.is_a?(Java::OrgApacheSolrServlet::DirectSolrConnection)
+      @connection = opts
+    else
+      opts[:data_dir] ||= File.join(opts[:home_dir].to_s, 'data')
+      if opts[:dist_dir] and ! opts[:jar_paths]
+        # add the standard lib and dist directories to the :jar_paths
+        opts[:jar_paths] = [File.join(opts[:dist_dir], 'lib'), File.join(opts[:dist_dir], 'dist')]
+      end
+      @opts = opts
+    end
+  end
+  
+  # loads/imports the java dependencies
+  # sets the @connection instance variable if it has not yet been set
+  def connection
+    @connection ||= (
+      require_jars(@opts[:jar_paths]) if @opts[:jar_paths]
+      org.apache.solr.servlet.DirectSolrConnection.new(opts[:home_dir], @opts[:data_dir], nil)
+    )
+  end
+  
+  def close
+    if @connection
+      @connection.close
+      @connection=nil
+    end
+  end
+  
+  # send a request to the connection
+  # request '/select', :q=>'something'
+  # request '/update', :wt=>:xml, '</commit>'
+  def request(path, params={}, data=nil, opts={})
+    data = data.to_xml if data.respond_to?(:to_xml)
+    url = build_url(path, params)
+    begin
+      body = connection.request(url, data)
+    rescue
+      raise RSolr::RequestError.new($!.message)
+    end
+    {
+      :body=>body,
+      :url=>url,
+      :path=>path,
+      :params=>params,
+      :data=>data,
+    }
+  end
+  
+  protected
+  
+  # require the jar files
+  def require_jars(paths)
+    paths = [paths] unless paths.is_a?(Array)
+    paths.each do |path|
+      raise "Invalid jar path: #{path}" unless File.exists?(path)
+      jar_pattern = File.join(path,"**", "*.jar")
+      Dir[jar_pattern].each {|jar_file| require jar_file }
+    end
+  end
+  
+end

data/lib/rsolr/connection/adapter/http.rb

@@ -0,0 +1,42 @@
+#
+# Connection for standard HTTP Solr server
+#
+class RSolr::Connection::Adapter::HTTP
+  
+  include RSolr::HTTPClient::Util
+  
+  attr_reader :opts
+  
+  # opts can have:
+  #   :url => 'http://localhost:8080/solr'
+  def initialize(opts={}, &block)
+    opts[:url] ||= 'http://127.0.0.1:8983/solr'
+    @opts = opts
+  end
+  
+  def connection
+    @connection ||= RSolr::HTTPClient.connect(@opts)
+  end
+  
+  # send a request to the connection
+  # request '/update', :wt=>:xml, '</commit>'
+  def request(path, params={}, *extra)
+    opts = extra[-1].kind_of?(Hash) ? extra.pop : {}
+    data = extra[0]
+    # force a POST, use the query string as the POST body
+    if opts[:method] == :post and data.to_s.empty?
+      http_context = connection.post(path, hash_to_query(params), {}, {'Content-Type' => 'application/x-www-form-urlencoded'})
+    else
+      if data
+        # standard POST, using "data" as the POST body
+        http_context = connection.post(path, data, params, {"Content-Type" => 'text/xml; charset=utf-8'})
+      else
+        # standard GET
+        http_context = connection.get(path, params)
+      end
+    end
+    raise RSolr::RequestError.new(http_context[:body]) unless http_context[:status_code] == 200
+    http_context
+  end
+  
+end

data/lib/rsolr/http_client.rb

@@ -0,0 +1,149 @@
+# 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/
+
+# Each adapters' response should be a hash with the following keys:
+#   :status_code
+#   :url
+#   :body
+#   :path
+#   :params
+#   :data
+#   :headers
+
+# Example:
+#   hclient = RSolr::HTTPClient.connect('http://www.google.com')
+#   # SAME AS
+#   hclient = RSolr::HTTPClient.connect(:net_http, 'http://www.google.com')
+#   hclient = RSolr::HTTPClient.connect(:curb, '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
+  
+  module Adapter
+    autoload :Curb, 'rsolr/http_client/adapter/curb'
+    autoload :NetHTTP, 'rsolr/http_client/adapter/net_http'
+  end
+  
+  class UnkownAdapterError < RuntimeError
+  end
+  
+  class Base
+
+    attr_reader :adapter
+  
+    # requires an instace of RSolr::HTTPClient::*
+    def initialize(adapter)
+      @adapter = adapter
+    end
+  
+    # sends a GET reqest to the "path" variable
+    # an optional hash of "params" can be used,
+    # which is later transformed into a GET query string
+    def get(path, params={})
+      begin
+        http_context = @adapter.get(path, params)
+      rescue
+        raise RSolr::RequestError.new($!)
+      end
+      http_context
+    end
+  
+    # sends a POST request to the "path" variable
+    # "data" is required, and must be a string
+    # "params" is an optional hash for query string params...
+    # "headers" is a hash for setting request header values.
+    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
+  
+  # Factory for creating connections.
+  # Can specify the connection type by
+  # using :net_http or :curb for the first argument.
+  # The ending arguments are always used for the connection adapter instance.
+  #
+  # Examples:
+  # # default net_http connection
+  # RSolr::HTTPClient.connect :url=>''
+  # # SAME AS
+  # RSolr::HTTPClient.connect :net_http, :url=>''
+  # # curb connection
+  # RSolr.connect :curb, :url=>''
+  def self.connect(*args)
+    type = args.first.is_a?(Symbol) ? args.shift : :net_http
+    opts = args
+    klass = case type
+    when :net_http,nil
+      'NetHTTP'
+    when :curb
+      'Curb'
+    else
+      raise UnkownAdapterError.new("Invalid adapter type: #{type} - use :curb or :net_http or blank for :net_http/default")
+    end
+    begin
+      Base.new Adapter.const_get(klass).new(*args)
+    end
+  end
+  
+  module Util
+    
+    # Performs URI escaping so that you can construct proper
+    # query strings faster.  Use this rather than the cgi.rb
+    # version since it's faster.  (Stolen from Rack).
+    def escape(s)
+      s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/n) {
+        '%'+$1.unpack('H2'*$1.size).join('%').upcase
+      }.tr(' ', '+')
+    end
+    
+    # creates and returns a url as a string
+    # "url" is the base url
+    # "params" is an optional hash of GET style query params
+    # "string_query" is an extra query string that will be appended to the 
+    # result of "url" and "params".
+    def build_url(url='', params={}, string_query='')
+      queries = [string_query, hash_to_query(params)]
+      queries.delete_if{|i| i.to_s.empty?}
+      url += "?#{queries.join('&')}" unless queries.empty?
+      url
+    end
+    
+    # converts a key value pair to an escaped string:
+    # Example:
+    # build_param(:id, 1) == "id=1"
+    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_query(: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_query(params)
+      params.map { |k, v|
+        if v.class == Array
+          hash_to_query(v.map { |x| [k, x] })
+        else
+          build_param k, v
+        end
+      }.join("&")
+    end
+    
+  end
+  
+end