rsolr 1.1.2 → 2.3.0

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/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

@@ -11,7 +11,7 @@ module RSolr::Response
     @request = request
     @response = response
     self.merge!(result)
-    if self["response"] && self["response"]["docs"].is_a?(Array)
+    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"]
@@ -41,7 +41,7 @@ module RSolr::Response
   end
 
   # A response module which gets mixed into the solr ["response"]["docs"] array.
-  class PaginatedDocSet < Array
+  class PaginatedDocSet < ::Array
 
     attr_accessor :page_start, :per_page, :page_total
     if not (Object.const_defined?("RUBY_ENGINE") and Object::RUBY_ENGINE=='rbx')

data/lib/rsolr/uri.rb

@@ -1,11 +1,6 @@
 require 'uri'
 
 module RSolr::Uri
-  
-  def create url
-    ::URI.parse (url[-1] == '/' || URI.parse(url).query) ? url : "#{url}/"
-  end
-  
   # Creates a Solr based query string.
   # Keys that have arrays values are set multiple times:
   #   params_to_solr(:q => 'query', :fq => ['a', 'b'])
@@ -13,13 +8,13 @@ module RSolr::Uri
   #   ?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 params_to_solr(params, escape = true)
+  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
+      if v.class == ::Array
         params_to_solr(v.map { |x| [k, x] }, false)
       else
         "#{k}=#{v}"
@@ -27,49 +22,4 @@ module RSolr::Uri
     end
     mapped.compact.join("&")
   end
-  
-  # Returns a query string param pair as a string.
-  # Both key and value are URI escaped, unless third param is false
-  # @param [boolean] escape false if no URI escaping is to be performed.  Default true.
-  # @deprecated - used to be called from params_to_solr before 2015-02-25
-  def build_param(k, v, escape = true)
-    warn "[DEPRECATION] `RSolr::Uri.build_param` is deprecated.  Use `URI.encode_www_form_component` or k=v instead."
-    escape ? 
-      "#{URI.encode_www_form_component(k)}=#{URI.encode_www_form_component(v)}" :
-      "#{k}=#{v}"
-  end
-
-  # 2015-02  Deprecated: use URI.encode_www_form_component(s)
-  #
-  # 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).
-  #  http://www.rubydoc.info/github/rack/rack/URI.encode_www_form_component
-  # @deprecated
-  def escape_query_value(s)
-    warn "[DEPRECATION] `RSolr::Uri.escape_query_value` is deprecated.  Use `URI.encode_www_form_component` instead."
-    URI.encode_www_form_component(s)
-#    s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/u) {
-#      '%'+$1.unpack('H2'*bytesize($1)).join('%').upcase
-#    }.tr(' ', '+')
-  end
-
-  # Return the bytesize of String; uses String#size under Ruby 1.8 and
-  # String#bytesize under 1.9.
-  # @deprecated  as bytesize was only used by escape_query_value which is itself deprecated
-  if ''.respond_to?(:bytesize)
-    def bytesize(string)
-      warn "[DEPRECATION] `RSolr::Uri.bytesize` is deprecated.  Use String.bytesize"
-      string.bytesize
-    end
-  else
-    def bytesize(string)
-      warn "[DEPRECATION] `RSolr::Uri.bytesize` is deprecated.  Use String.size"
-      string.size
-    end
-  end
-
-  extend self
-  
 end

data/lib/rsolr/version.rb

@@ -1,5 +1,5 @@
 module RSolr
-  VERSION = "1.1.2"
+  VERSION = "2.3.0"
 
   def self.version
     VERSION

data/lib/rsolr/xml.rb

@@ -1,102 +1,8 @@
-begin; require 'nokogiri'; rescue LoadError; end
-require 'time'
-
 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)
-        wrap(values).each do |v|
-          v = format_value(v)
-          next if v.empty?
-          @fields << RSolr::Xml::Field.new({:name=>field}, v)
-        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
-
-    private
-
-    def format_value(v)
-      case v
-      when Time
-        v.getutc.iso8601
-      when DateTime
-        v.to_time.getutc.iso8601
-      when Date
-        Time.utc(v.year, v.mon, v.mday).iso8601
-      else
-        v.to_s
-      end
-    end
-
-    def wrap(object)
-      if object.nil?
-        []
-      elsif object.respond_to?(:to_ary)
-        object.to_ary || [object]
-      elsif object.is_a? Enumerable
-        object
-      else
-        [object]
-      end
-    end
-  end
+  Document = RSolr::Document
+  Field = RSolr::Field
 
-  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
+  class Generator < RSolr::Generator
     class << self
       attr_accessor :use_nokogiri
 
@@ -110,7 +16,14 @@ module RSolr::Xml
         end
       end
     end
-    self.use_nokogiri = (defined?(::Nokogiri::XML::Builder) and not defined?(JRuby)) ? true : false
+    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|
@@ -158,17 +71,13 @@ module RSolr::Xml
     #
     def add data, add_attrs = nil, &block
       add_attrs ||= {}
-      data = [data] unless data.is_a?(Array)
+      data = RSolr::Array.wrap(data)
       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)
+            doc = RSolr::Document.new(doc) if doc.respond_to?(:each_pair)
             yield doc if block_given?
-            doc_node_builder = lambda do |doc_node|
-              doc.fields.each do |field_obj|
-                doc_node.field field_obj.value, field_obj.attrs
-              end
-            end
+            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
@@ -195,7 +104,7 @@ module RSolr::Xml
     # 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)
+      ids = RSolr::Array.wrap(ids)
       build do |xml|
         xml.delete do |delete_node|
           ids.each do |id| 
@@ -208,12 +117,34 @@ module RSolr::Xml
     # 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)
+      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