telvue-rsolr 2.2.2

data/lib/rsolr/document.rb

@@ -0,0 +1,59 @@
+module RSolr
+  class Document
+    CHILD_DOCUMENT_KEY = '_childDocuments_'.freeze
+
+    # "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|
+        add_field(field, values)
+      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, values, options = {})
+      RSolr::Array.wrap(values).each do |v|
+        field_attrs = { name: name }
+        field_attrs[:type] = DocumentField if name.to_s == CHILD_DOCUMENT_KEY
+
+        @fields << RSolr::Field.instance(options.merge(field_attrs), v)
+      end
+    end
+
+    def as_json
+      @fields.group_by(&:name).each_with_object({}) do |(field, values), result|
+        v = values.map(&:as_json)
+        if v.length > 1 && v.first.is_a?(Hash) && v.first.key?(:value)
+          v = v.first.merge(value: v.map { |single| single[:value] })
+        end
+        v = v.first if v.length == 1 && field.to_s != CHILD_DOCUMENT_KEY
+        result[field] = v
+      end
+    end
+  end
+end

data/lib/rsolr/error.rb

@@ -0,0 +1,136 @@
+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
+        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
+  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 InvalidResponse < 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