oauth-rsolr 0.12.1

data/Manifest

@@ -0,0 +1,14 @@
+README.rdoc
+Rakefile
+VERSION
+lib/rsolr.rb
+lib/rsolr/client.rb
+lib/rsolr/connection.rb
+lib/rsolr/connection/net_http.rb
+lib/rsolr/connection/requestable.rb
+lib/rsolr/connection/utils.rb
+lib/rsolr/message.rb
+lib/rsolr/message/document.rb
+lib/rsolr/message/field.rb
+lib/rsolr/message/generator.rb
+Manifest

data/README.rdoc

@@ -0,0 +1,13 @@
+= tsxn-rsolr
+
+A simple, extensible Ruby client for Apache Solr. MODIFIED/CUSTOMIZED to add OAuth request signing for POST requests to support 2-legged OAuth.
+
+== Credits
+
+The original gem was written by Matt Mitchell and is located at http://github.com/mwmitchell/rsolr.
+
+== Usage
+
+See the usage of the original gem at http://github.com/mwmitchell/rsolr.  
+
+The additional setup requires that the OAuth consumer key be specified in ENV["oauth_key"] and the OAuth consumer secret be specified in ENV["oauth_secret"].  Only HMAC-SHA1 is supported.

data/Rakefile

@@ -0,0 +1,13 @@
+require 'rubygems'
+require 'rake'
+require 'echoe'
+
+Echoe.new('oauth-rsolr', '0.12.1') do |p|
+  p.description    = "RSolr aims to provide a simple and extensible library for working with Solr.  This is a CUSTOMIZED version that OAuth signs every POST request for 2-legged OAuth.  Only supports HMAC-SHA1.  The original gem was written by Matt Mitchell and is located at http://github.com/mwmitchell/rsolr."
+  p.url            = "http://github.com/tsxn26/tsxn-rsolr"
+  p.author         = ["Matt Mitchell", "Thomas Nguyen"]
+  p.email          = "tsxn26@gmail.com"
+  p.ignore_pattern = ["tmp/*", "script/*"]
+  p.development_dependencies = []
+  p.runtime_dependencies = ["builder >=2.1.2", "ruby-hmac"]
+end

data/VERSION

@@ -0,0 +1 @@
+0.12.1

data/lib/rsolr.rb

@@ -0,0 +1,50 @@
+
+require 'rubygems'
+$:.unshift File.dirname(__FILE__) unless $:.include?(File.dirname(__FILE__))
+
+module RSolr
+  
+  def self.version
+    @version ||= File.read(File.join(File.dirname(__FILE__), '..', 'VERSION'))
+  end
+  
+  VERSION = self.version
+  
+  autoload :Message, 'rsolr/message'
+  autoload :Client, 'rsolr/client'
+  autoload :Connection, 'rsolr/connection'
+  
+  module Connectable
+    
+    def connect opts={}
+      Client.new Connection::NetHttp.new(opts)
+    end
+    
+  end
+  
+  extend Connectable
+  
+  # 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
+  
+  # send the escape method into the Connection class ->
+  # solr = RSolr.connect
+  # solr.escape('asdf')
+  RSolr::Client.send(:include, Char)
+  
+  # bring escape into this module (RSolr) -> RSolr.escape('asdf')
+  extend Char
+  
+  # RequestError is a common/generic exception class used by the adapters
+  class RequestError < RuntimeError; end
+  
+end

data/lib/rsolr/client.rb

@@ -0,0 +1,116 @@
+class RSolr::Client
+  
+  attr_reader :connection
+  
+  # "connection" is instance of:
+  #   RSolr::Adapter::HTTP
+  #   RSolr::Adapter::Direct (jRuby only)
+  # or any other class that uses the connection "interface"
+  def initialize(connection)
+    @connection = connection
+  end
+  
+  # Send a request to a request handler using the method name.
+  # Also proxies to the #paginate method if the method starts with "paginate_"
+  def method_missing(method_name, *args, &blk)
+    request("/#{method_name}", *args, &blk)
+  end
+  
+  # sends data to the update handler
+  # data can be a string of xml, or an object that returns xml from its #to_xml method
+  def update(data, params={})
+    params.merge!({"oauth_signature_method"=>"HMAC-SHA1", "oauth_timestamp"=>Time.now.to_i.to_s, "oauth_nonce"=>Time.now.to_i.to_s})
+    params.merge!({"oauth_consumer_key"=>ENV["oauth_key"], "oauth_version"=>"1.0"})
+    request '/update', params, data
+  end
+  
+  # send request solr
+  # params is hash with valid solr request params (:q, :fl, :qf etc..)
+  #   if params[:wt] is not set, the default is :ruby
+  #   if :wt is something other than :ruby, the raw response body is used
+  #   otherwise, a simple Hash is returned
+  #   NOTE: to get raw ruby, use :wt=>'ruby' <- a string, not a symbol like :ruby  
+  #
+  #
+  def request(path, params={}, *extra)
+    response = @connection.request(path, map_params(params), *extra)
+    adapt_response(response)
+  end
+  
+  # 
+  # single record:
+  # solr.update(:id=>1, :name=>'one')
+  #
+  # update using an array
+  # solr.update([{:id=>1, :name=>'one'}, {:id=>2, :name=>'two'}])
+  #
+  def add(doc, &block)
+    update message.add(doc, &block)
+  end
+
+  # send </commit>
+  def commit
+    update message.commit
+  end
+
+  # send </optimize>
+  def optimize
+    update message.optimize
+  end
+
+  # send </rollback>
+  # NOTE: solr 1.4 only
+  def rollback
+    update message.rollback
+  end
+
+  # Delete one or many documents by id
+  #   solr.delete_by_id 10
+  #   solr.delete_by_id([12, 41, 199])
+  def delete_by_id(id)
+    update message.delete_by_id(id)
+  end
+
+  # delete one or many documents by query
+  #   solr.delete_by_query 'available:0'
+  #   solr.delete_by_query ['quantity:0', 'manu:"FQ"']
+  def delete_by_query(query)
+    update message.delete_by_query(query)
+  end
+  
+  # shortcut to RSolr::Message::Generator
+  def message *opts
+    @message ||= RSolr::Message::Generator.new
+  end
+  
+  protected
+  
+  # sets default params etc.. - could be used as a mapping hook
+  # type of request should be passed in here? -> map_params(:query, {})
+  def map_params(params)
+    params||={}
+    {:wt=>:ruby}.merge(params)
+  end
+
+  # "connection_response" must be a hash with the following keys:
+  #   :params - a sub hash of standard solr params
+  #   : body - the raw response body from the solr server
+  # This method will evaluate the :body value if the params[:wt] == :ruby
+  # otherwise, the body is returned
+  # The return object has a special method attached called #raw
+  # This method gives you access to the original response from the connection,
+  # so you can access things like the actual :url sent to solr,
+  # the raw :body, original :params and original :data
+  def adapt_response(connection_response)
+    data = connection_response[:body]
+    # if the wt is :ruby, evaluate the ruby string response
+    if connection_response[:params][:wt] == :ruby
+      data = Kernel.eval(data)
+    end
+    # attach a method called #raw that returns the original connection response value
+    def data.raw; @raw end
+    data.send(:instance_variable_set, '@raw', connection_response)
+    data
+  end
+  
+end

data/lib/rsolr/connection.rb

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

data/lib/rsolr/connection/net_http.rb

@@ -0,0 +1,98 @@
+require 'net/http'
+require 'hmac-sha1'
+
+#
+# Connection for standard HTTP Solr server
+#
+class RSolr::Connection::NetHttp
+  
+  include RSolr::Connection::Requestable
+  
+  def connection
+    @connection ||= Net::HTTP.new(@uri.host, @uri.port)
+  end
+  
+  def get path, params={}
+    url = self.build_url path, params
+    net_http_response = self.connection.get url
+    create_http_context net_http_response, url, path, params
+  end
+  
+  def post path, data, params={}, headers={}
+    add_signature("POST", path, params)
+    
+    url = self.build_url path, params
+    net_http_response = self.connection.post url, data, headers
+    create_http_context net_http_response, url, path, params, data, headers
+  end
+  
+  def create_http_context net_http_response, url, path, params, data=nil, headers={}
+    full_url = "#{@uri.scheme}://#{@uri.host}"
+    full_url += @uri.port ? ":#{@uri.port}" : ''
+    full_url += url
+    {
+      :status_code=>net_http_response.code.to_i,
+      :url=>full_url,
+      :body=> encode_utf8(net_http_response.body),
+      :path=>path,
+      :params=>params,
+      :data=>data,
+      :headers=>headers,
+      :message => net_http_response.message
+    }
+  end
+  
+  # accepts a path/string and optional hash of query params
+  def build_url path, params={}
+    full_path = @uri.path + path
+    super full_path, params, @uri.query
+  end
+  
+  def normalize_params(params)
+    return_string = ""
+    params.keys.sort{|x,y| x.to_s <=> y.to_s}.each do |k|
+      v = params[k]
+      if v.class == Array
+        v.sort.each {|v| return_string.concat("#{k.to_s}=#{v}&")}
+      else
+        return_string.concat("#{k.to_s}=#{v}&")
+      end 
+    end
+    if !return_string.blank?
+      return_string.chop!
+    end
+    return_string
+  end
+  
+  def create_base_string(method, path, params)
+    url = "#{@uri.scheme}://#{@uri.host}"
+    port = @uri.port.to_s
+    if !port.blank?
+      if port != "80"
+        url += ":#{port}"
+      end
+    end  
+    url += @uri.path + path
+    signature_base = method.upcase
+    signature_base.concat("&")
+    signature_base.concat(CGI::escape(url))
+    signature_base.concat("&")
+    signature_base.concat(CGI::escape(normalize_params(params)))
+  end
+  
+  def create_signature(base_string, consumer_secret, token_secret="")
+    secret = "#{escape(consumer_secret)}&#{escape(token_secret)}" 
+    Base64.encode64(HMAC::SHA1.digest(secret, base_string)).chomp.gsub(/\n/,'') 
+  end  
+  
+  def escape(value)
+    CGI.escape(value.to_s).gsub("%7E", '~').gsub("+", "%20")
+  end
+  
+  def add_signature(http_method, path, params) 
+    base_string = create_base_string(http_method, path, params)
+    signature = create_signature(base_string, ENV["oauth_secret"])
+    params.merge!("oauth_signature" => signature)
+  end
+  
+end

data/lib/rsolr/connection/requestable.rb

@@ -0,0 +1,43 @@
+# A module that defines the interface and top-level logic for http based connection classes.
+module RSolr::Connection::Requestable
+  
+  include RSolr::Connection::Utils
+  
+  attr_reader :opts, :uri
+  
+  # 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]
+  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
+    opts = extra[-1].kind_of?(Hash) ? extra.pop : {}
+    data = extra[0]
+    # force a POST, use the query string as the POST body
+    if opts[:method] == :post and data.to_s.empty?
+      http_context = self.post(path, hash_to_query(params), {}, {'Content-Type' => 'application/x-www-form-urlencoded'})
+    else
+      if data
+        # standard POST, using "data" as the POST body
+        http_context = self.post(path, data, params, {"Content-Type" => 'text/xml; charset=utf-8'})
+      else
+        # standard GET
+        http_context = self.get(path, params)
+      end
+    end
+    raise RSolr::RequestError.new("Solr Response: #{http_context[:message]}") unless http_context[:status_code] == 200
+    http_context
+  end
+  
+end

data/lib/rsolr/connection/utils.rb

@@ -0,0 +1,106 @@
+# Helpful utility methods for building queries to a Solr server
+# This includes helpers that the Direct connection can use.
+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#length 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', :fq=>['blah', 'blah'], :facet=>{:field=>['location_facet', 'format_facet']})
+  # returns:
+  #   ?q=blah&fq=blah&fq=blah&facet.field=location_facet&facet.field=format.facet
+  #
+  # if a value is empty/nil etc., it is not added
+  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
+
+  def normalize_params(params)
+    return_string = ""
+    params.keys.sort.each do |k|
+      v = params[k]
+      if v.class == Array
+        v.sort.each {|v| return_string.concat("#{k}=#{v}&")}
+      else
+        return_string.concat("#{k}=#{v}&")
+      end 
+    end
+    if !return_string.blank?
+      return_string.chop!
+    end
+    return_string
+  end
+  
+  def create_base_string(method, url, params)
+    signature_base = method.upcase
+    signature_base.concat("&")
+    signature_base.concat(CGI::escape(url))
+    signature_base.concat("&")
+    signature_base.concat(CGI::escape(normalize_params(params)))
+  end
+  
+  def create_signature(base_string, consumer_secret, token_secret="")
+    require "hmac-sha1"
+    secret = "#{escape(consumer_secret)}&#{escape(token_secret)}" 
+    Base64.encode64(HMAC::SHA1.digest(secret, base_string)).chomp.gsub(/\n/,'') 
+  end  
+  
+  def escape(value)
+    CGI.escape(value.to_s).gsub("%7E", '~').gsub("+", "%20")
+  end
+end

data/lib/rsolr/message.rb

@@ -0,0 +1,8 @@
+# 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/lib/rsolr/message/document.rb

@@ -0,0 +1,48 @@
+# 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

@@ -0,0 +1,20 @@
+# 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

@@ -0,0 +1,89 @@
+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/oauth-rsolr.gemspec

@@ -0,0 +1,36 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{oauth-rsolr}
+  s.version = "0.12.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Matt Mitchell, Thomas Nguyen"]
+  s.date = %q{2010-04-13}
+  s.description = %q{RSolr aims to provide a simple and extensible library for working with Solr.  This is a CUSTOMIZED version that OAuth signs every POST request for 2-legged OAuth.  Only supports HMAC-SHA1.  The original gem was written by Matt Mitchell and is located at http://github.com/mwmitchell/rsolr.}
+  s.email = %q{tsxn26@gmail.com}
+  s.extra_rdoc_files = ["README.rdoc", "lib/rsolr.rb", "lib/rsolr/client.rb", "lib/rsolr/connection.rb", "lib/rsolr/connection/net_http.rb", "lib/rsolr/connection/requestable.rb", "lib/rsolr/connection/utils.rb", "lib/rsolr/message.rb", "lib/rsolr/message/document.rb", "lib/rsolr/message/field.rb", "lib/rsolr/message/generator.rb"]
+  s.files = ["README.rdoc", "Rakefile", "VERSION", "lib/rsolr.rb", "lib/rsolr/client.rb", "lib/rsolr/connection.rb", "lib/rsolr/connection/net_http.rb", "lib/rsolr/connection/requestable.rb", "lib/rsolr/connection/utils.rb", "lib/rsolr/message.rb", "lib/rsolr/message/document.rb", "lib/rsolr/message/field.rb", "lib/rsolr/message/generator.rb", "Manifest", "oauth-rsolr.gemspec"]
+  s.homepage = %q{http://github.com/tsxn26/tsxn-rsolr}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Oauth-rsolr", "--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{oauth-rsolr}
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{RSolr aims to provide a simple and extensible library for working with Solr.  This is a CUSTOMIZED version that OAuth signs every POST request for 2-legged OAuth.  Only supports HMAC-SHA1.  The original gem was written by Matt Mitchell and is located at http://github.com/mwmitchell/rsolr.}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<builder>, [">= 2.1.2"])
+      s.add_runtime_dependency(%q<ruby-hmac>, [">= 0"])
+    else
+      s.add_dependency(%q<builder>, [">= 2.1.2"])
+      s.add_dependency(%q<ruby-hmac>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<builder>, [">= 2.1.2"])
+    s.add_dependency(%q<ruby-hmac>, [">= 0"])
+  end
+end

metadata

@@ -0,0 +1,117 @@
+--- !ruby/object:Gem::Specification 
+name: oauth-rsolr
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 12
+  - 1
+  version: 0.12.1
+platform: ruby
+authors: 
+- Matt Mitchell, Thomas Nguyen
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-13 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: builder
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 1
+        - 2
+        version: 2.1.2
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: ruby-hmac
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+description: RSolr aims to provide a simple and extensible library for working with Solr.  This is a CUSTOMIZED version that OAuth signs every POST request for 2-legged OAuth.  Only supports HMAC-SHA1.  The original gem was written by Matt Mitchell and is located at http://github.com/mwmitchell/rsolr.
+email: tsxn26@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- lib/rsolr.rb
+- lib/rsolr/client.rb
+- lib/rsolr/connection.rb
+- lib/rsolr/connection/net_http.rb
+- lib/rsolr/connection/requestable.rb
+- lib/rsolr/connection/utils.rb
+- lib/rsolr/message.rb
+- lib/rsolr/message/document.rb
+- lib/rsolr/message/field.rb
+- lib/rsolr/message/generator.rb
+files: 
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/rsolr.rb
+- lib/rsolr/client.rb
+- lib/rsolr/connection.rb
+- lib/rsolr/connection/net_http.rb
+- lib/rsolr/connection/requestable.rb
+- lib/rsolr/connection/utils.rb
+- lib/rsolr/message.rb
+- lib/rsolr/message/document.rb
+- lib/rsolr/message/field.rb
+- lib/rsolr/message/generator.rb
+- Manifest
+- oauth-rsolr.gemspec
+has_rdoc: true
+homepage: http://github.com/tsxn26/tsxn-rsolr
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Oauth-rsolr
+- --main
+- README.rdoc
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 2
+      version: "1.2"
+requirements: []
+
+rubyforge_project: oauth-rsolr
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: RSolr aims to provide a simple and extensible library for working with Solr.  This is a CUSTOMIZED version that OAuth signs every POST request for 2-legged OAuth.  Only supports HMAC-SHA1.  The original gem was written by Matt Mitchell and is located at http://github.com/mwmitchell/rsolr.
+test_files: []
+