rsolr 0.12.0 → 2.6.0

data/lib/rsolr/error.rb

@@ -0,0 +1,182 @@
+require 'json'
+
+module RSolr::Error
+
+  module URICleanup
+    # Removes username and password from URI object.
+    def clean_uri(uri)
+      uri = uri.dup
+      uri.password = "REDACTED" if uri.password
+      uri.user = "REDACTED" if uri.user
+      uri
+    end
+  end
+
+  module SolrContext
+    include URICleanup
+
+    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: #{clean_uri(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
+        # Default JSON response, try to parse and retrieve error message
+        if response[:headers] && response[:headers]["content-type"].start_with?("application/json")
+          begin
+            parsed_body = JSON.parse(body)
+            info = parsed_body && parsed_body["error"] && parsed_body["error"]["msg"]
+          rescue JSON::ParserError
+          end
+        end
+        return info if info
+
+        # legacy analysis, I think trying to handle wt=ruby responses without
+        # a full parse?
+        if body =~ /<pre>/
+          info = body.scan(/<pre>(.*)<\/pre>/mi)[0]
+        elsif body =~ /'msg'=>/
+          info = body.scan(/'msg'=>(.*)/)[0]
+        end
+        info = info.join if info.respond_to? :join
+        info ||= body  # body might not contain <pre> or msg elements
+
+        partial = info.to_s.split("\n")[0..10]
+        partial.join("\n").gsub("&gt;", ">").gsub("&lt;", "<")
+      rescue
+        nil
+      end
+    end
+  end
+
+  class ConnectionRefused < ::Errno::ECONNREFUSED
+    include URICleanup
+
+    def initialize(request)
+      request[:uri] = clean_uri(request[:uri])
+
+      super(request.inspect)
+    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
+      response = response_with_force_encoded_body(response)
+      @request, @response = request, response
+    end
+
+    private
+
+    def response_with_force_encoded_body(response)
+      response[:body] = response[:body].force_encoding('UTF-8') if response
+      response
+    end
+  end
+
+  # Thrown if the :wt is :ruby
+  # but the body wasn't succesfully parsed/evaluated
+  class InvalidResponse < Http
+
+  end
+
+  # Subclasses Rsolr::Error::Http for legacy backwards compatibility
+  # purposes, because earlier RSolr 2 didn't distinguish these
+  # from Http errors.
+  #
+  # In RSolr 3, it could make sense to `< Timeout::Error` instead,
+  # analagous to ConnectionRefused above
+  class Timeout < Http
+  end
+
+  # Thrown if the :wt is :ruby
+  # but the body wasn't succesfully parsed/evaluated
+  class InvalidJsonResponse < InvalidResponse
+
+  end
+
+  # Thrown if the :wt is :ruby
+  # but the body wasn't succesfully parsed/evaluated
+  class InvalidRubyResponse < InvalidResponse
+
+  end
+
+end

data/lib/rsolr/field.rb

@@ -0,0 +1,87 @@
+module RSolr
+  class Field
+    def self.instance(attrs, value)
+      attrs = attrs.dup
+      field_type = attrs.delete(:type) {  value.class.name }
+
+      klass = if field_type.is_a? String
+                class_for_field(field_type)
+              elsif field_type.is_a? Class
+                field_type
+              else
+                self
+              end
+
+      klass.new(attrs, value)
+    end
+
+    def self.class_for_field(field_type)
+      potential_class_name = field_type + 'Field'.freeze
+      search_scope = Module.nesting[1]
+      search_scope.const_defined?(potential_class_name, false) ? search_scope.const_get(potential_class_name) : self
+    end
+    private_class_method :class_for_field
+
+    # "attrs" is a hash for setting the "doc" xml attributes
+    # "value" is the text value for the node
+    attr_accessor :attrs, :source_value
+
+    # "attrs" must be a hash
+    # "value" should be something that responds to #_to_s
+    def initialize(attrs, source_value)
+      @attrs = attrs
+      @source_value = source_value
+    end
+
+    # the value of the "name" attribute
+    def name
+      attrs[:name]
+    end
+
+    def value
+      source_value
+    end
+
+    def as_json
+      if attrs[:update]
+        { attrs[:update] => value }
+      elsif attrs.any? { |k, _| k != :name }
+        hash = attrs.dup
+        hash.delete(:name)
+        hash.merge(value: value)
+      else
+        value
+      end
+    end
+  end
+
+  class DateField < Field
+    def value
+      Time.utc(source_value.year, source_value.mon, source_value.mday).iso8601
+    end
+  end
+
+  class TimeField < Field
+    def value
+      source_value.getutc.strftime('%FT%TZ')
+    end
+  end
+
+  class DateTimeField < Field
+    def value
+      source_value.to_time.getutc.iso8601
+    end
+  end
+
+  class DocumentField < Field
+    def value
+      return RSolr::Document.new(source_value) if source_value.respond_to? :each_pair
+
+      super
+    end
+
+    def as_json
+      value.as_json
+    end
+  end
+end

data/lib/rsolr/generator.rb

@@ -0,0 +1,5 @@
+module RSolr
+  class Generator
+    
+  end
+end

data/lib/rsolr/json.rb

@@ -0,0 +1,60 @@
+require 'json'
+
+module RSolr::JSON
+  class Generator < RSolr::Generator
+    CONTENT_TYPE = 'application/json'.freeze
+
+    def content_type
+      CONTENT_TYPE
+    end
+
+    def add data, add_attrs = {}
+      add_attrs ||= {}
+      data = RSolr::Array.wrap(data)
+
+      if add_attrs.empty? && data.none? { |doc| doc.is_a?(RSolr::Document) && !doc.attrs.empty? }
+        data.map do |doc|
+          doc = RSolr::Document.new(doc) if doc.respond_to?(:each_pair)
+          yield doc if block_given?
+          doc.as_json
+        end.to_json
+      else
+        i = 0
+        data.each_with_object({}) do |doc, hash|
+          doc = RSolr::Document.new(doc) if doc.respond_to?(:each_pair)
+          yield doc if block_given?
+          hash["add__UNIQUE_RSOLR_SUFFIX_#{i += 1}"] = add_attrs.merge(doc.attrs).merge(doc: doc.as_json)
+        end.to_json.gsub(/__UNIQUE_RSOLR_SUFFIX_\d+/, '')
+      end
+    end
+
+    # generates a commit message
+    def commit(opts = {})
+      opts ||= {}
+      { commit: opts }.to_json
+    end
+
+    # generates a optimize message
+    def optimize(opts = {})
+      opts ||= {}
+      { optimize: opts }.to_json
+    end
+
+    # generates a rollback message
+    def rollback
+      { rollback: {} }.to_json
+    end
+
+    # generates a delete message
+    # "ids" can be a single value or array of values
+    def delete_by_id(ids)
+      { delete: ids }.to_json
+    end
+
+    # generates a delete message
+    # "queries" can be a single value or an array of values
+    def delete_by_query(queries)
+      { delete: { query: queries } }.to_json
+    end
+  end
+end

data/lib/rsolr/response.rb

@@ -0,0 +1,95 @@
+module RSolr::Response
+
+  def self.included(base)
+    unless base < Hash
+      raise ArgumentError, "RSolr::Response expects to included only in (sub)classes of Hash; got included in '#{base}' instead."
+    end
+    base.send(:attr_reader, :request, :response)
+  end
+
+  def initialize_rsolr_response(request, response, result)
+    @request = request
+    @response = response
+    self.merge!(result)
+    if self["response"] && self["response"]["docs"].is_a?(::Array)
+      docs = PaginatedDocSet.new(self["response"]["docs"])
+      docs.per_page = request[:params]["rows"]
+      docs.page_start = request[:params]["start"]
+      docs.page_total = self["response"]["numFound"].to_s.to_i
+      self["response"]["docs"] = docs
+    end
+  end
+
+  def with_indifferent_access
+    if defined?(::RSolr::HashWithIndifferentAccessWithResponse)
+      ::RSolr::HashWithIndifferentAccessWithResponse.new(request, response, self)
+    else
+      if defined?(ActiveSupport::HashWithIndifferentAccess)
+        RSolr.const_set("HashWithIndifferentAccessWithResponse", Class.new(ActiveSupport::HashWithIndifferentAccess))
+        RSolr::HashWithIndifferentAccessWithResponse.class_eval <<-eos
+          include RSolr::Response
+          def initialize(request, response, result)
+            super()
+            initialize_rsolr_response(request, response, result)
+          end
+        eos
+        ::RSolr::HashWithIndifferentAccessWithResponse.new(request, response, self)
+      else
+        raise RuntimeError, "HashWithIndifferentAccess is not currently defined"
+      end
+    end
+  end
+
+  # A response module which gets mixed into the solr ["response"]["docs"] array.
+  class PaginatedDocSet < ::Array
+
+    attr_accessor :page_start, :per_page, :page_total
+    if not (Object.const_defined?("RUBY_ENGINE") and Object::RUBY_ENGINE=='rbx')
+      alias_method(:start,:page_start)
+      alias_method(:start=,:page_start=)
+      alias_method(:total,:page_total)
+      alias_method(:total=,:page_total=)
+    end
+
+    # 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
+
+class RSolr::HashWithResponse < Hash
+  include RSolr::Response
+
+  def initialize(request, response, result)
+    super()
+    initialize_rsolr_response(request, response, result || {})
+  end
+end

data/lib/rsolr/uri.rb

@@ -0,0 +1,25 @@
+require 'uri'
+
+module RSolr::Uri
+  # 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
+  # @param [boolean] escape false if no URI escaping is to be performed.  Default true.
+  # @return [String] Solr query params as a String, suitable for use in a url
+  def self.params_to_solr(params, escape = true)
+    return URI.encode_www_form(params.reject{|k,v| k.to_s.empty? || v.to_s.empty?}) if escape
+
+    # escape = false if we are here
+    mapped = params.map do |k, v|
+      next if v.to_s.empty?
+      if v.class == ::Array
+        params_to_solr(v.map { |x| [k, x] }, false)
+      else
+        "#{k}=#{v}"
+      end
+    end
+    mapped.compact.join("&")
+  end
+end

data/lib/rsolr/version.rb

@@ -0,0 +1,7 @@
+module RSolr
+  VERSION = "2.6.0"
+
+  def self.version
+    VERSION
+  end
+end

data/lib/rsolr/xml.rb

@@ -0,0 +1,150 @@
+module RSolr::Xml
+  Document = RSolr::Document
+  Field = RSolr::Field
+
+  class Generator < RSolr::Generator
+    class << self
+      attr_accessor :use_nokogiri
+
+      def builder_proc
+        if use_nokogiri 
+          require 'nokogiri' unless defined?(::Nokogiri::XML::Builder)
+          :nokogiri_build
+        else
+          require 'builder' unless defined?(::Builder::XmlMarkup)
+          :builder_build
+        end
+      end
+    end
+    self.use_nokogiri = defined?(::Nokogiri::XML::Builder) ? true : false
+
+    CONTENT_TYPE = 'text/xml'.freeze
+
+    def content_type
+      CONTENT_TYPE
+    end
+
+
+    def nokogiri_build &block
+      b = ::Nokogiri::XML::Builder.new do |xml|
+        block_given? ? yield(xml) : xml
+      end
+      '<?xml version="1.0" encoding="UTF-8"?>'+b.to_xml(:indent => 0, :encoding => 'UTF-8', :save_with => ::Nokogiri::XML::Node::SaveOptions::AS_XML | ::Nokogiri::XML::Node::SaveOptions::NO_DECLARATION).strip
+    end
+    protected :nokogiri_build
+    
+    def builder_build &block
+      b = ::Builder::XmlMarkup.new(:indent => 0, :margin => 0, :encoding => 'UTF-8')
+      b.instruct!
+      block_given? ? yield(b) : b
+    end
+    protected :builder_build
+    
+    def build &block
+      self.send(self.class.builder_proc,&block)
+    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 = RSolr::Array.wrap(data)
+      build do |xml|
+        xml.add(add_attrs) do |add_node|
+          data.each do |doc|
+            doc = RSolr::Document.new(doc) if doc.respond_to?(:each_pair)
+            yield doc if block_given?
+            doc_node_builder = to_xml(doc)
+            self.class.use_nokogiri ? add_node.doc_(doc.attrs,&doc_node_builder) : add_node.doc(doc.attrs,&doc_node_builder)
+          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 = RSolr::Array.wrap(ids)
+      build do |xml|
+        xml.delete do |delete_node|
+          ids.each do |id| 
+            self.class.use_nokogiri ? delete_node.id_(id) : delete_node.id(id)
+          end
+        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 = RSolr::Array.wrap(queries)
+      build do |xml|
+        xml.delete do |delete_node|
+          queries.each { |query| delete_node.query(query) }
+        end
+      end
+    end
+
+    private
+
+    def to_xml(doc)
+      lambda do |doc_node|
+        doc.fields.each do |field_obj|
+          value = field_obj.value
+
+          if field_obj.name.to_s == RSolr::Document::CHILD_DOCUMENT_KEY
+            child_node_builder = to_xml(field_obj.value)
+            self.class.use_nokogiri ? doc_node.doc_(&child_node_builder) : doc_node.doc(&child_node_builder)
+          elsif value.is_a?(Hash) && value.length == 1 && field_obj.attrs[:update].nil?
+            update_attr, real_value = value.first
+            doc_node.field real_value, field_obj.attrs.merge(update: update_attr)
+          elsif value.nil?
+            doc_node.field field_obj.value, field_obj.attrs.merge(null: true)
+          else
+            doc_node.field field_obj.value, field_obj.attrs
+          end
+        end
+      end
+    end
+  end
+end