rsolr 0.12.0 → 1.0.3

data/lib/rsolr/connection.rb

@@ -1,9 +1,78 @@
-require 'uri'
-
-module RSolr::Connection
-  
-  autoload :NetHttp, 'rsolr/connection/net_http'
-  autoload :Utils, 'rsolr/connection/utils'
-  autoload :Requestable, 'rsolr/connection/requestable'
-  
-end
+require 'net/http'
+require 'net/https'
+
+# The default/Net::Http adapter for RSolr.
+class RSolr::Connection
+
+  # using the request_context hash,
+  # send a request,
+  # then return the standard rsolr response hash {:status, :body, :headers}
+  def execute client, request_context
+    h = http request_context[:uri], request_context[:proxy]
+    request = setup_raw_request request_context
+    request.body = request_context[:data] if request_context[:method] == :post and request_context[:data]
+    begin
+      response = h.request request
+      charset = response.type_params["charset"]
+      {:status => response.code.to_i, :headers => response.to_hash, :body => force_charset(response.body, charset)}
+    # catch the undefined closed? exception -- this is a confirmed ruby bug
+    rescue NoMethodError
+      $!.message == "undefined method `closed?' for nil:NilClass" ?
+        raise(Errno::ECONNREFUSED.new) :
+        raise($!)
+    end
+  end
+
+  protected
+
+  # This returns a singleton of a Net::HTTP or Net::HTTP.Proxy request object.
+  def http uri, proxy = nil
+    @http ||= (
+      http = if proxy
+        proxy_user, proxy_pass = proxy.userinfo.split(/:/) if proxy.userinfo
+        Net::HTTP.Proxy(proxy.host, proxy.port, proxy_user, proxy_pass).new uri.host, uri.port
+      else
+        Net::HTTP.new uri.host, uri.port
+      end
+      http.use_ssl = uri.port == 443 || uri.instance_of?(URI::HTTPS)
+      http
+    )
+  end
+
+  #
+  def setup_raw_request request_context
+    http_method = case request_context[:method]
+    when :get
+      Net::HTTP::Get
+    when :post
+      #require 'net/http/post/multipart'
+      #File === request_context[:data] ? Net::HTTP::Post::Multipart : Net::HTTP::Post
+      Net::HTTP::Post
+    when :head
+      Net::HTTP::Head
+    else
+      raise "Only :get, :post and :head http method types are allowed."
+    end
+    headers = request_context[:headers] || {}
+    # if http_method.to_s == "Net::HTTP::Post::Multipart"
+    #   io = request_context[:data]
+    #   UploadIO.convert! io, request_context[:headers]["Content-Type"], io.path, io.path
+    #   raw_request =
+    #     Net::HTTP::Post::Multipart.new(
+    #       request_context[:path],
+    #       :file => io)
+    # else
+      raw_request = http_method.new request_context[:uri].request_uri
+    # end
+    raw_request.initialize_http_header headers
+    raw_request
+  end
+
+  private
+
+  def force_charset body, charset
+    return body unless charset and body.respond_to?(:force_encoding)
+    body.force_encoding(charset)
+  end
+
+end

data/lib/rsolr/error.rb

@@ -0,0 +1,117 @@
+module RSolr::Error
+  
+  module SolrContext
+    
+    attr_accessor :request, :response
+    
+    def to_s
+      m = "#{super.to_s}"
+      if response
+        m << " - #{response[:status]} #{Http::STATUS_CODES[response[:status].to_i]}"
+        details = parse_solr_error_response response[:body]
+        m << "\nError: #{details}\n" if details
+      end
+      p = "\nURI: #{request[:uri].to_s}"
+      p = "\nRequest Headers: #{request[:headers].inspect}" if request[:headers]
+      p = "\nRequest Data: #{request[:data].inspect}" if request[:data]
+      p << "\n"
+      p << "\nBacktrace: " + self.backtrace[0..10].join("\n")
+      m << p
+      m
+    end
+    
+    protected
+    
+    def parse_solr_error_response body
+      begin
+        info = body.scan(/<pre>(.*)<\/pre>/mi)[0]
+        info = info.join if info.respond_to? :join
+
+        info ||= body  # body may not contain <pre> elements
+
+        partial = info.to_s.split("\n")[0..10]
+        partial.join("\n").gsub("&gt;", ">").gsub("&lt;", "<")
+      rescue
+        nil
+      end
+    end
+    
+  end
+  
+  class Http < RuntimeError
+    
+    include SolrContext
+    
+    # ripped right from ActionPack
+    # Defines the standard HTTP status codes, by integer, with their
+    # corresponding default message texts.
+    # Source: http://www.iana.org/assignments/http-status-codes
+    STATUS_CODES = {
+      100 => "Continue",
+      101 => "Switching Protocols",
+      102 => "Processing",
+
+      200 => "OK",
+      201 => "Created",
+      202 => "Accepted",
+      203 => "Non-Authoritative Information",
+      204 => "No Content",
+      205 => "Reset Content",
+      206 => "Partial Content",
+      207 => "Multi-Status",
+      226 => "IM Used",
+
+      300 => "Multiple Choices",
+      301 => "Moved Permanently",
+      302 => "Found",
+      303 => "See Other",
+      304 => "Not Modified",
+      305 => "Use Proxy",
+      307 => "Temporary Redirect",
+
+      400 => "Bad Request",
+      401 => "Unauthorized",
+      402 => "Payment Required",
+      403 => "Forbidden",
+      404 => "Not Found",
+      405 => "Method Not Allowed",
+      406 => "Not Acceptable",
+      407 => "Proxy Authentication Required",
+      408 => "Request Timeout",
+      409 => "Conflict",
+      410 => "Gone",
+      411 => "Length Required",
+      412 => "Precondition Failed",
+      413 => "Request Entity Too Large",
+      414 => "Request-URI Too Long",
+      415 => "Unsupported Media Type",
+      416 => "Requested Range Not Satisfiable",
+      417 => "Expectation Failed",
+      422 => "Unprocessable Entity",
+      423 => "Locked",
+      424 => "Failed Dependency",
+      426 => "Upgrade Required",
+
+      500 => "Internal Server Error",
+      501 => "Not Implemented",
+      502 => "Bad Gateway",
+      503 => "Service Unavailable",
+      504 => "Gateway Timeout",
+      505 => "HTTP Version Not Supported",
+      507 => "Insufficient Storage",
+      510 => "Not Extended"
+    }
+    
+    def initialize request, response
+      @request, @response = request, response
+    end
+    
+  end
+  
+  # Thrown if the :wt is :ruby
+  # but the body wasn't succesfully parsed/evaluated
+  class InvalidRubyResponse < Http
+    
+  end
+  
+end

data/lib/rsolr/response.rb

@@ -0,0 +1,51 @@
+module RSolr::Response
+  
+  def self.extended base
+    if base["response"] && base["response"]["docs"]
+      base["response"]["docs"].tap do |d|
+        d.extend PaginatedDocSet
+        d.per_page = base.request[:params]["rows"]
+        d.start = base.request[:params]["start"]
+        d.total = base["response"]["numFound"].to_s.to_i
+      end
+    end
+  end
+  
+  # A response module which gets mixed into the solr ["response"]["docs"] array.
+  module PaginatedDocSet
+
+    attr_accessor :start, :per_page, :total
+
+    # Returns the current page calculated from 'rows' and 'start'
+    def current_page
+      return 1 if start < 1
+      per_page_normalized = per_page < 1 ? 1 : per_page
+      @current_page ||= (start / per_page_normalized).ceil + 1
+    end
+
+    # Calcuates the total pages from 'numFound' and 'rows'
+    def total_pages
+      @total_pages ||= per_page > 0 ? (total / per_page.to_f).ceil : 1
+    end
+
+    # returns the previous page number or 1
+    def previous_page
+      @previous_page ||= (current_page > 1) ? current_page - 1 : 1
+    end
+
+    # returns the next page number or the last
+    def next_page
+      @next_page ||= (current_page == total_pages) ? total_pages : current_page+1
+    end
+
+    def has_next?
+      current_page < total_pages
+    end
+
+    def has_previous?
+      current_page > 1
+    end
+
+  end
+  
+end

data/lib/rsolr/uri.rb

@@ -0,0 +1,58 @@
+require 'uri'
+
+module RSolr::Uri
+  
+  def create url
+    ::URI.parse url[-1] == ?/ ? url : "#{url}/"
+  end
+  
+  # Returns a query string param pair as a string.
+  # Both key and value are escaped.
+  def build_param(k,v, escape = true)
+    escape ? 
+      "#{escape_query_value(k)}=#{escape_query_value(v)}" :
+      "#{k}=#{v}"
+  end
+
+  # Return the bytesize of String; uses String#size under Ruby 1.8 and
+  # String#bytesize under 1.9.
+  if ''.respond_to?(:bytesize)
+    def bytesize(string)
+      string.bytesize
+    end
+  else
+    def bytesize(string)
+      string.size
+    end
+  end
+
+  # Creates a Solr based query string.
+  # Keys that have arrays values are set multiple times:
+  #   params_to_solr(:q => 'query', :fq => ['a', 'b'])
+  # is converted to:
+  #   ?q=query&fq=a&fq=b
+  def params_to_solr(params, escape = true)
+    mapped = params.map do |k, v|
+      next if v.to_s.empty?
+      if v.class == Array
+        params_to_solr(v.map { |x| [k, x] }, escape)
+      else
+        build_param k, v, escape
+      end
+    end
+    mapped.compact.join("&")
+  end
+  
+  # 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_query_value(s)
+    s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/u) {
+      '%'+$1.unpack('H2'*bytesize($1)).join('%').upcase
+    }.tr(' ', '+')
+  end
+  
+  extend self
+  
+end

data/lib/rsolr/xml.rb

@@ -0,0 +1,165 @@
+require 'builder'
+
+module RSolr::Xml
+  
+  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 << RSolr::Xml::Field.new({:name=>field}, v.to_s)
+        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
+
+    #
+    # Add a field value to the document. Options map directly to
+    # XML attributes in the Solr <field> node.
+    # See http://wiki.apache.org/solr/UpdateXmlMessages#head-8315b8028923d028950ff750a57ee22cbf7977c6
+    #
+    # === Example:
+    #
+    #   document.add_field('title', 'A Title', :boost => 2.0)
+    #
+    def add_field(name, value, options = {})
+      @fields << RSolr::Xml::Field.new(options.merge({:name=>name}), value)
+    end
+    
+  end
+  
+  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 Generator
+    
+    def build &block
+      b = ::Builder::XmlMarkup.new(:indent => 0, :margin => 0, :encoding => 'UTF-8')
+      b.instruct!
+      block_given? ? yield(b) : b
+    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 = nil, &block
+      add_attrs ||= {}
+      data = [data] unless data.is_a?(Array)
+      build do |xml|
+        xml.add(add_attrs) do |add_node|
+          data.each do |doc|
+            doc = RSolr::Xml::Document.new(doc) if doc.respond_to?(:each_pair)
+            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
+    end
+    
+    # generates a <commit/> message
+    def commit opts = nil
+      opts ||= {}
+      build {|xml| xml.commit(opts) }
+    end
+    
+    # generates a <optimize/> message
+    def optimize opts = nil
+      opts ||= {}
+      build {|xml| xml.optimize(opts) }
+    end
+    
+    # generates a <rollback/> message
+    def rollback
+      build {|xml| 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)
+      build do |xml|
+        xml.delete do |delete_node|
+          ids.each { |id| delete_node.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)
+      build do |xml|
+        xml.delete do |delete_node|
+          queries.each { |query| delete_node.query(query) }
+        end
+      end
+    end
+    
+  end
+  
+end

data/lib/rsolr-direct.rb

@@ -0,0 +1,111 @@
+require 'java'
+require 'rubygems'
+require 'rsolr'
+
+#
+# Connection for JRuby + DirectSolrConnection
+#
+module RSolr::Direct
+  
+  # load the java libs that ship with rsolr-direct
+  # RSolr.load_java_libs
+  # rsolr = RSolr.connect :direct, :solr_home => ''
+  def self.load_java_libs apache_solr_dir
+    @java_libs_loaded ||= (
+      base_dir = File.expand_path(apache_solr_dir)
+      ['lib', 'dist'].each do |sub|
+        Dir[File.join(base_dir, sub, '*.jar')].each do |jar|
+          require jar
+        end
+      end
+      true
+    )
+  end
+  
+  RSolr.class_eval do
+    # RSolr.direct_connect :solr_home => 'apache-solr/example/solr'
+    # RSolr.direct_connect java_solr_core
+    # RSolr.direct_connect java_direct_solr_connection
+    def self.direct_connect *args, &blk
+      client = RSolr::Client.new RSolr::Direct::Connection.new(*args), {:url => false}
+      if block_given?
+        yield client
+        client.connection.close
+        nil
+      else
+        client
+      end
+    end
+  end
+  
+  class Connection
+    
+    attr_accessor :opts
+    
+    class MissingRequiredJavaLibs < RuntimeError
+    end
+    
+    class InvalidSolrHome < RuntimeError
+    end
+    
+    # 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[:solr_home] is absolute path to solr home (the directory with "data", "config" etc.)
+    def initialize opts
+      begin
+        org.apache.solr.servlet.DirectSolrConnection
+      rescue NameError
+        raise MissingRequiredJavaLibs
+      end
+      if opts.is_a?(Hash) and opts[:solr_home]
+        raise InvalidSolrHome unless File.exists?(opts[:solr_home])
+        opts[:data_dir] ||= File.join(opts[:solr_home], 'data')
+        @opts = opts
+      elsif opts.class.to_s == "Java::OrgApacheSolrCore::SolrCore"
+        @direct = org.apache.solr.servlet.DirectSolrConnection.new(opts)
+      elsif opts.class.to_s == "Java::OrgApacheSolrServlet::DirectSolrConnection"
+        @direct = opts
+      end
+      opts[:auto_connect] = true unless opts.key?(:auto_connect)
+      self.direct if opts[:auto_connect]
+    end
+    
+    # sets the @direct instance variable if it has not yet been set
+    def direct
+      @direct ||= org.apache.solr.servlet.DirectSolrConnection.new(opts[:solr_home], @opts[:data_dir], nil)
+    end
+    
+    # rsolr.connection.open
+    alias_method :open, :direct
+    
+    def close
+      if @direct
+        @direct.close
+        @direct = nil
+      end
+    end
+    
+    # send a request to the connection
+    def execute client, request_context
+      #data = request_context[:data]
+      #data = data.to_xml if data.respond_to?(:to_xml)
+      url = [request_context[:path], request_context[:query]].join("?")
+      url = "/" + url unless url[0].chr == "/"
+      begin
+        body = direct.request(url, request_context[:data])
+      rescue
+        $!.extend RSolr::Error::SolrContext
+        $!.request = request_context
+        raise $!
+      end
+      {
+        :status => 200,
+        :body => body,
+        :headers => {}
+      }
+    end
+    
+  end
+  
+end

data/lib/rsolr.rb

@@ -1,40 +1,24 @@
+$: << "#{File.dirname(__FILE__)}" unless $:.include? File.dirname(__FILE__)
 
 require 'rubygems'
-$:.unshift File.dirname(__FILE__) unless $:.include?(File.dirname(__FILE__))
 
 module RSolr
   
-  VERSION = '0.12.0'
+  %W(Response Char Client Error Connection Uri Xml).each{|n|autoload n.to_sym, "rsolr/#{n.downcase}"}
   
-  autoload :Message, 'rsolr/message'
-  autoload :Client, 'rsolr/client'
-  autoload :Connection, 'rsolr/connection'
-  
-  def self.connect opts={}
-    Client.new Connection::NetHttp.new(opts)
+  def self.version
+    @version ||= File.read(File.join(File.dirname(__FILE__), '..', 'VERSION')).chomp
   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
+  VERSION = self.version
   
-  # send the escape method into the Connection class ->
-  # solr = RSolr.connect
-  # solr.escape('asdf')
-  RSolr::Client.send(:include, Char)
+  def self.connect *args
+    driver = Class === args[0] ? args[0] : RSolr::Connection
+    opts = Hash === args[-1] ? args[-1] : {}
+    Client.new driver.new, opts
+  end
   
-  # bring escape into this module (RSolr) -> RSolr.escape('asdf')
+  # RSolr.escape
   extend Char
   
-  # RequestError is a common/generic exception class used by the adapters
-  class RequestError < RuntimeError; end
-  
 end

data/spec/api/char_spec.rb

@@ -0,0 +1,18 @@
+require 'spec_helper'
+describe "RSolr::Char" do
+  
+  let(:char){Object.new.extend RSolr::Char}
+  
+  it 'should escape everything that is not a word with \\' do
+    (0..255).each do |ascii|
+      chr = ascii.chr
+      esc = char.escape(chr)
+      if chr =~ /\W/
+        esc.to_s.should == "\\#{chr}"
+      else
+        esc.to_s.should == chr
+      end
+    end
+  end
+  
+end