rsolr 0.13.0.pre → 1.0.0.beta

data/lib/rsolr/connection/httpable.rb

@@ -1,101 +0,0 @@
-# A module that defines the interface and top-level logic for http based connection classes.
-# Httpable provides URL parsing and handles proxy logic.
-
-module RSolr::Connection::Httpable
-  
-  include RSolr::Connection::Utils
-  
-  attr_reader :opts, :uri, :proxy
-  
-  # opts can have:
-  #   :url => 'http://localhost:8080/solr'
-  def initialize opts={}
-    opts[:url] ||= 'http://127.0.0.1:8983/solr'
-    @opts = opts
-    @uri = URI.parse opts[:url]
-    @proxy = URI.parse opts[:proxy] if opts[:proxy]
-  end
-  
-  # send a request to the connection
-  # request '/select', :q=>'*:*'
-  #
-  # request '/update', {:wt=>:xml}, '</commit>'
-  # 
-  # force a post where the post body is the param query
-  # request '/update', "<optimize/>", :method=>:post
-  #
-  def request path, params={}, *extra
-    extra = extra.dup
-    opts = extra[-1].kind_of?(Hash) ? extra.pop : {}
-    data = extra[0]
-    
-    context = create_http_context path, params, data, opts
-    
-    error = nil
-    
-    begin
-      
-      # if data is being sent, this is a POST
-      if context[:data]
-        response = self.post context[:path], context[:data], context[:headers]
-      # use POST if :method => :post
-      elsif opts[:method] == :post
-        response = self.post context[:path], context[:query], context[:headers]
-      # GET
-      else
-        response = self.get context[:path]
-      end
-      
-      # spray out our response into variables...
-      body, status_code, message = response
-      
-      # merge the response into the http context
-      context.merge!(:body => body, :status_code => status_code, :message => message)
-      
-    rescue
-      # throw RequestError?
-      context[:message] = $!.to_s
-    end
-    
-    # if no :message but a non-200, throw a "SolrRequestError" ?
-    unless context[:status_code] == 200
-      error = context[:message] || "Non-200 Response Status Code" 
-      raise RSolr::RequestError.new("#{error} -> #{context.inspect}")
-    end
-    
-    context
-  end
-  
-  # -> should this stuff be in a "ReqResContext" class? ->
-  
-  # creates a Hash based "context"
-  # that contains all of the information sent to Solr
-  # The keys are:
-  #   :host, :path, :params, :query, :data, :headers
-  def create_http_context path, params, data=nil, opts={}
-    context = {:host => base_url, :path => build_url(path), :params => params, :query => hash_to_query(params), :data => data}
-    if opts[:method] == :post
-      raise "Don't send POST data when using :method => :post" unless data.to_s.empty?
-      # force a POST, use the query string as the POST body
-      context.merge! :data => hash_to_query(params), :headers => {'Content-Type' => 'application/x-www-form-urlencoded'}
-    elsif data
-      # standard POST, using "data" as the POST body
-      context.merge! :headers => {'Content-Type' => 'text/xml; charset=utf-8'}
-    else
-      context.merge! :path => build_url(path, params)
-    end
-    context
-  end
-  
-  # accepts a path/string and optional hash of query params
-  # returns a string that represents the full url
-  def build_url path, params={}
-    full_path = @uri.path + path
-    super full_path, params, @uri.query
-  end
-  
-  def base_url
-    "#{@uri.scheme}://#{@uri.host}" + (@uri.port ? ":#{@uri.port}" : "")
-  end
-
-end

data/lib/rsolr/connection/net_http.rb

@@ -1,30 +0,0 @@
-require 'net/http'
-
-#
-# Connection for standard HTTP Solr server
-#
-class RSolr::Connection::NetHttp
-  
-  include RSolr::Connection::Httpable
-  
-  def connection
-    if @proxy
-      proxy_user, proxy_pass = @proxy.userinfo.split(/:/) if @proxy.userinfo
-      @connection ||= Net::HTTP.Proxy(@proxy.host, @proxy.port, proxy_user, proxy_pass).new(@uri.host, @uri.port)
-    else
-      @connection ||= Net::HTTP.new(@uri.host, @uri.port)
-    end
-  end
-  
-  # maybe follow Rack and do [status, headers, body]
-  def get url
-    net_http_response = self.connection.get url
-    [net_http_response.code.to_i, net_http_response.message, net_http_response.body]
-  end
-  
-  def post url, data, headers={}
-    net_http_response = self.connection.post url, data, headers
-    [net_http_response.code.to_i, net_http_response.message, net_http_response.body]
-  end
-  
-end

data/lib/rsolr/connection/utils.rb

@@ -1,74 +0,0 @@
-# Helpful utility methods for building queries to a Solr server
-# This includes helpers that the Direct connection can use --  not specific to http, for example
-module RSolr::Connection::Utils
-  
-  # 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
-      '%'+$1.unpack('H2'*bytesize($1)).join('%').upcase
-    }.tr(' ', '+')
-  end
-  
-  # encodes the string as utf-8 in Ruby 1.9
-  # returns the unaltered string in Ruby 1.8
-  def encode_utf8 string
-    (string.respond_to?(:force_encoding) and string.respond_to?(:encoding)) ?
-      string.force_encoding(Encoding::UTF_8) : string
-  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 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-query', :fq=>['f1', 'f1'], :facet=>true, 'facet.field'=>['location_facet', 'format_facet'])
-  # returns:
-  #   ?q=blah-query&fq=f1&fq=f2&facet=true&facet.field=location_facet&facet.field=format.facet
-  #
-  # if a value is empty/nil etc., it is tossed out
-  #
-  def hash_to_query(params)
-    mapped = params.map do |k, v|
-      next if v.to_s.empty?
-      if v.class == Array
-        hash_to_query(v.map { |x| [k, x] })
-      else
-        build_param k, v
-      end
-    end
-    mapped.compact.join("&")
-  end
-  
-end

data/lib/rsolr/connection.rb

@@ -1,9 +0,0 @@
-require 'uri'
-
-module RSolr::Connection
-  
-  autoload :NetHttp, 'rsolr/connection/net_http'
-  autoload :Utils, 'rsolr/connection/utils'
-  autoload :Httpable, 'rsolr/connection/httpable'
-  
-end

data/lib/rsolr/message/document.rb

@@ -1,48 +0,0 @@
-# A class that represents a "doc" xml element for a solr update
-class RSolr::Message::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::Message::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::Message::Field.new(options.merge({:name=>name}), value)
-  end
-  
-end

data/lib/rsolr/message/field.rb

@@ -1,20 +0,0 @@
-# A class that represents a "doc"/"field" xml element for a solr update
-class RSolr::Message::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

data/lib/rsolr/message/generator.rb

@@ -1,89 +0,0 @@
-class RSolr::Message::Generator
-  
-  def build &block
-    require 'builder'
-    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={}, &block
-    data = [data] unless data.is_a?(Array)
-    build do |xml|
-      xml.add(add_attrs) do |add_node|
-        data.each do |doc|
-          doc = RSolr::Message::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={})
-    build {|xml| xml.commit opts}
-  end
-  
-  # generates a <optimize/> message
-  def optimize(opts={})
-    build {|xml| xml.optimize opts}
-  end
-  
-  # generates a <rollback/> message
-  def rollback opts={}
-    build {|xml| xml.rollback opts}
-  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

data/lib/rsolr/message.rb

@@ -1,8 +0,0 @@
-# The Solr::Message::Generator class is the XML generation module for sending updates to Solr.
-module RSolr::Message
-  
-  autoload :Document, 'rsolr/message/document'
-  autoload :Field, 'rsolr/message/field'
-  autoload :Generator, 'rsolr/message/generator'
-  
-end

data/spec/api/client_spec.rb

@@ -1,115 +0,0 @@
-describe RSolr::Client do
-  
-  let(:client){ RSolr::Client.new('') }
-  
-  context :method_missing do
-    
-    it 'a non-existent method should be forwarded to #method_missing and then to #request' do
-      client.should_receive(:request).
-        with('/music', :q=>'Coltrane')
-      client.music :q=>'Coltrane'
-    end
-    
-  end
-  
-  context :update do
-    
-    it 'should forward /update to #request("/update")' do
-      client.should_receive(:request)#.
-      #  with('/update', {:wt=>:ruby}, "my xml message")
-      client.update "my xml message"
-    end
-    
-    it 'should forward #add calls to #update' do
-      client.should_receive(:update) {|value,params|
-        value.should == "<?xml version=\"1.0\" encoding=\"UTF-8\"?><add><doc><field name=\"id\">1</field></doc></add>"
-      }
-      client.add(:id=>1)
-    end
-
-    it 'should forward #commit calls to #update' do
-      client.should_receive(:update).
-        with("<?xml version=\"1.0\" encoding=\"UTF-8\"?><commit/>")
-      client.commit
-    end
-
-    it 'should forward #commit calls with options to #update' do
-      opts = {:waitFlush => false, :waitSearcher => false, :expungeDeletes => true}
-      # when client.commit is called, it eventually calls update
-      client.should_receive(:update).
-        with(opts)
-      # client.message is calls to create the xml
-      client.message.should_receive(:commit).
-        and_return(opts)
-      client.commit(opts)
-    end
-    
-    it 'should forward #optimize calls to #update' do
-      client.should_receive(:update).
-        with("<?xml version=\"1.0\" encoding=\"UTF-8\"?><optimize/>")
-      client.optimize
-    end
-
-    it 'should forward #optimize calls with options to #update' do
-      opts = {:maxSegments => 5, :waitFlush => false}
-      # when client.commit is called, it eventually calls update
-      client.should_receive(:update).
-        with(opts)
-      # client.message is calls to create the xml
-      client.message.should_receive(:optimize).
-        and_return(opts)
-      client.optimize(opts)
-    end
-    
-    it 'should forward #rollback calls to #update' do
-      client.should_receive(:update).
-        with("<?xml version=\"1.0\" encoding=\"UTF-8\"?><rollback/>")
-      client.rollback
-    end
-    
-    it 'should forward #delete_by_id calls to #update' do
-      client.should_receive(:update).
-        with("<?xml version=\"1.0\" encoding=\"UTF-8\"?><delete><id>1</id></delete>")
-      client.delete_by_id 1
-    end
-    
-    it 'should forward #delete_by_query calls to #update' do
-      client.should_receive(:update).
-        with("<?xml version=\"1.0\" encoding=\"UTF-8\"?><delete><query>blah</query></delete>")
-      client.delete_by_query 'blah'
-    end
-    
-  end
-  
-  context :request do
-    
-    it 'should forward #request calls to the connection' do
-      client.connection.should_receive(:request).
-        with('/music', :q=>'Coltrane', :wt=>:ruby).
-          # empty params so that Client doesn't try to evalulate to Ruby;
-          #   -- this happens if the :wt equal :ruby
-          and_return(:params=>{})
-      client.request '/music', :q=>'Coltrane'
-    end
-
-  end
-
-  context :adapt_response do
-    
-    it 'should not try to evaluate ruby when the :qt is not :ruby' do
-      body = '{:time=>"NOW"}'
-      result = client.send(:adapt_response, {:body=>body, :params=>{}})
-      result.should be_a(String)
-      result.should == body
-    end
-    
-    it 'should evaluate ruby responses when the :wt is :ruby' do
-      body = '{:time=>"NOW"}'
-      result = client.send(:adapt_response, {:body=>body, :params=>{:wt=>:ruby}})
-      result.should be_a(Hash)
-      result.should == {:time=>"NOW"}
-    end
-    
-  end
-  
-end

data/spec/api/connection/httpable_spec.rb

@@ -1,157 +0,0 @@
-describe RSolr::Connection::Httpable do
-  
-  # calls #let to set "net_http" as method accessor
-  class R
-    include RSolr::Connection::Httpable
-  end
-  
-  module HttpableHelper
-    def self.included base
-      base.let(:httpable){R.new}
-    end
-  end
-  
-  context 'new' do
-    
-    include HttpableHelper
-    
-    it 'should define an intialize method that accepts a hash argument' do
-      lambda{R.new({})}.should_not raise_error 
-    end
-  
-    it 'should have an #opts attribute after creation' do
-      httpable.should respond_to(:opts)
-    end
-  
-    it 'should have an #uri attribute after creation' do
-      httpable.should respond_to(:uri)
-    end
-    
-  end
-  
-  context 'opts and uri' do
-    
-    it 'should allow setting the opts' do
-      opts = {:url=>'blah'}
-      r = R.new(opts)
-      r.opts.should == opts
-    end
-    
-    it 'should parser the url option into a URI object' do
-      opts = {:url => 'http://xyz:1010/solr'}
-      r = R.new(opts)
-      r.uri.should be_a(URI)
-      r.uri.host.should == 'xyz'
-    end
-    
-  end
-  
-  context :build_url do
-    
-    include HttpableHelper
-    
-    it 'should build a full path and create a query string' do
-      r = httpable
-      r.build_url("/select", :q=>1).should == '/solr/select?q=1'
-    end
-    
-    it 'should build a full path without a query string' do
-      r = httpable
-      r.build_url("/select").should == '/solr/select'
-    end
-    
-  end
-  
-  context :create_http_context do
-    
-    include HttpableHelper
-    
-    it "should build a simple GET context" do
-      r = httpable
-      result = r.create_http_context('/select', :q=>'a', :fq=>'b')
-      expected = {:path=>"/solr/select?q=a&fq=b", :params=>{:q=>"a", :fq=>"b"}, :data=>nil, :query=>"q=a&fq=b", :host=>"http://127.0.0.1:8983"}
-      
-      result.keys.all? {|v| expected.keys.include?(v) }
-      result.values.all? {|v| expected.values.include?(v) }
-    end
-    
-    it "should build a POST context" do
-      r = httpable
-      result = r.create_http_context('/select', {:wt => :xml}, '<commit/>')
-      expected = {:path=>"/solr/select", :params=>{:wt=>:xml}, :headers=>{"Content-Type"=>"text/xml; charset=utf-8"}, :data=>"<commit/>", :query=>"wt=xml", :host=>"http://127.0.0.1:8983"}
-      result.should == expected
-    end
-    
-    it "should raise an exception when trying to use POST data AND :method => :post" do
-      r = httpable
-      lambda{
-        r.create_http_context('/select', {:wt => :xml}, '<commit/>', :method => :post)
-      }.should raise_error("Don't send POST data when using :method => :post")
-    end
-    
-    it "should form-encoded POST context" do
-      r = httpable
-      result = r.create_http_context('/select', {:q => 'some gigantic query string that is too big for GET (for example)'}, nil, :method => :post)
-      result.should == {:path=>"/solr/select", :params=>{:q=>"some gigantic query string that is too big for GET (for example)"}, :headers=>{"Content-Type"=>"application/x-www-form-urlencoded"}, :data=>"q=some+gigantic+query+string+that+is+too+big+for+GET+%28for+example%29", :query=>"q=some+gigantic+query+string+that+is+too+big+for+GET+%28for+example%29", :host=>"http://127.0.0.1:8983"}
-    end
-    
-  end
-  
-  context :request do
-    
-    include HttpableHelper
-    
-    it "should be able to build a request context, pass the url to #get and return a full context" do
-      httpable.should_receive(:create_http_context).
-        with("/admin/ping", {}, nil, {}).
-          and_return({:path => '/solr/admin/ping'})
-      httpable.should_receive(:get).
-        with('/solr/admin/ping').
-          and_return(["asdfasdf", 200, "OK"])
-      response = httpable.request '/admin/ping'
-      response.should == {:status_code=>200, :message=>"OK", :path=>"/solr/admin/ping", :body=>"asdfasdf"}
-    end
-    
-    it 'should send a get to itself with params' do
-      httpable.should_receive(:get).
-        with("/solr/blahasdf?id=1").
-          and_return(["", 200, "OK"])
-      r = httpable.request('/blahasdf', :id=>1)
-      r.should == {:status_code=>200, :path=>"/solr/blahasdf?id=1", :params=>{:id=>1}, :message=>"OK", :data=>nil, :query=>"id=1", :host=>"http://127.0.0.1:8983", :body=>""}
-    end
-    
-    it 'should raise an error if the status_code is not 200' do
-      httpable.should_receive(:get).
-        with("/solr/blah?id=1").
-          and_return( ["", 404, "Not Found"] )
-      lambda{
-        httpable.request('/blah', :id=>1).should == true
-      }.should raise_error(/Not Found/)
-    end
-    
-    it 'should send a post to itself if data is supplied' do
-      httpable.should_receive(:post).
-        with("/solr/blah", "<commit/>", {"Content-Type"=>"text/xml; charset=utf-8"}).
-          and_return(["", 200, "OK"])
-      httpable.request('/blah', {:id=>1}, "<commit/>")#.should == expected_response
-    end
-    
-    it 'should send a post to itself when :method=>:post is set even if no POST data is supplied' do
-      httpable.should_receive(:post).
-        with("/solr/blah", "q=testing", {"Content-Type"=>"application/x-www-form-urlencoded"}).
-          and_return(["", 200, "OK"])
-      response = httpable.request('/blah', {:q => "testing"}, :method => :post)#.should == expected_response
-      response[:body].should == ""
-      response[:path].should == "/solr/blah"
-      response[:message].should == "OK"
-      response[:status_code].should == 200
-      response[:params].should == {:q=>"testing"}
-      response[:headers].should == {"Content-Type"=>"application/x-www-form-urlencoded"}
-      response[:data].should == "q=testing"
-      response[:query].should == "q=testing"
-      response[:host].should == "http://127.0.0.1:8983"
-    end
-    
-  end
-  
-end