mdwan-rsolr 0.8.2

data/lib/mash.rb

@@ -0,0 +1,148 @@
+# This class has dubious semantics and we only have it so that people can write
+# params[:key] instead of params['key'].
+class Mash < Hash
+
+  # @param constructor<Object>
+  #   The default value for the mash. Defaults to an empty hash.
+  #
+  # @details [Alternatives]
+  #   If constructor is a Hash, a new mash will be created based on the keys of
+  #   the hash and no default value will be set.
+  def initialize(constructor = {})
+    if constructor.is_a?(Hash)
+      super()
+      update(constructor)
+    else
+      super(constructor)
+    end
+  end
+
+  # @param key<Object> The default value for the mash. Defaults to nil.
+  #
+  # @details [Alternatives]
+  #   If key is a Symbol and it is a key in the mash, then the default value will
+  #   be set to the value matching the key.
+  def default(key = nil)
+    if key.is_a?(Symbol) && include?(key = key.to_s)
+      self[key]
+    else
+      super
+    end
+  end
+
+  alias_method :regular_writer, :[]= unless method_defined?(:regular_writer)
+  alias_method :regular_update, :update unless method_defined?(:regular_update)
+
+  # @param key<Object> The key to set.
+  # @param value<Object>
+  #   The value to set the key to.
+  #
+  # @see Mash#convert_key
+  # @see Mash#convert_value
+  def []=(key, value)
+    regular_writer(convert_key(key), convert_value(value))
+  end
+
+  # @param other_hash<Hash>
+  #   A hash to update values in the mash with. The keys and the values will be
+  #   converted to Mash format.
+  #
+  # @return <Mash> The updated mash.
+  def update(other_hash)
+    other_hash.each_pair { |key, value| regular_writer(convert_key(key), convert_value(value)) }
+    self
+  end
+
+  alias_method :merge!, :update
+
+  # @param key<Object> The key to check for. This will be run through convert_key.
+  #
+  # @return <TrueClass, FalseClass> True if the key exists in the mash.
+  def key?(key)
+    super(convert_key(key))
+  end
+
+  # def include? def has_key? def member?
+  alias_method :include?, :key?
+  alias_method :has_key?, :key?
+  alias_method :member?, :key?
+
+  # @param key<Object> The key to fetch. This will be run through convert_key.
+  # @param *extras<Array> Default value.
+  #
+  # @return <Object> The value at key or the default value.
+  def fetch(key, *extras)
+    super(convert_key(key), *extras)
+  end
+
+  # @param *indices<Array>
+  #   The keys to retrieve values for. These will be run through +convert_key+.
+  #
+  # @return <Array> The values at each of the provided keys
+  def values_at(*indices)
+    indices.collect {|key| self[convert_key(key)]}
+  end
+
+  # @param hash<Hash> The hash to merge with the mash.
+  #
+  # @return <Mash> A new mash with the hash values merged in.
+  def merge(hash)
+    self.dup.update(hash)
+  end
+
+  # @param key<Object>
+  #   The key to delete from the mash.\
+  def delete(key)
+    super(convert_key(key))
+  end
+
+  # @param *rejected<Array[(String, Symbol)] The mash keys to exclude.
+  #
+  # @return <Mash> A new mash without the selected keys.
+  #
+  # @example
+  #   { :one => 1, :two => 2, :three => 3 }.except(:one)
+  #     #=> { "two" => 2, "three" => 3 }
+  def except(*keys)
+    super(*keys.map {|k| convert_key(k)})
+  end
+
+  # Used to provide the same interface as Hash.
+  #
+  # @return <Mash> This mash unchanged.
+  def stringify_keys!; self end
+
+  # @return <Hash> The mash as a Hash with string keys.
+  def to_hash
+    Hash.new(default).merge(self)
+  end
+
+  protected
+  # @param key<Object> The key to convert.
+  #
+  # @param <Object>
+  #   The converted key. If the key was a symbol, it will be converted to a
+  #   string.
+  #
+  # @api private
+  def convert_key(key)
+    key.kind_of?(Symbol) ? key.to_s : key
+  end
+
+  # @param value<Object> The value to convert.
+  #
+  # @return <Object>
+  #   The converted value. A Hash or an Array of hashes, will be converted to
+  #   their Mash equivalents.
+  #
+  # @api private
+  def convert_value(value)
+    if value.class == Hash
+      value.to_mash
+    elsif value.is_a?(Array)
+      value.collect { |e| convert_value(e) }
+    else
+      value
+    end
+  end
+end

data/lib/rsolr.rb

@@ -0,0 +1,52 @@
+# add this directory to the load path if it hasn't already been added
+# load xout and rfuzz libs
+proc {|base, files|
+  $: << base unless $:.include?(base) || $:.include?(File.expand_path(base))
+  files.each {|f| require f}
+}.call(File.dirname(__FILE__), ['core_ext', 'mash'])
+
+module RSolr
+  
+  VERSION = '0.8.2'
+  
+  autoload :Message, 'rsolr/message'
+  autoload :Connection, 'rsolr/connection'
+  autoload :Adapter, 'rsolr/adapter'
+  autoload :HTTPClient, 'rsolr/http_client'
+  
+  # factory for creating connections
+  # "options" is a hash that gets used by the Connection
+  # object AND the adapter object.
+  def self.connect(options={})
+    adapter_name = options[:adapter] ||= :http
+    types = {
+      :http=>'HTTP',
+      :direct=>'Direct'
+    }
+    adapter_class = RSolr::Adapter.const_get(types[adapter_name])
+    adapter = adapter_class.new(options)
+    RSolr::Connection.new(adapter, options)
+  end
+  
+  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::Connection.send(:include, Char)
+  
+  # bring escape into this module (RSolr) -> RSolr.escape('asdf')
+  extend Char
+  
+  class RequestError < RuntimeError; end
+  
+end

data/lib/rsolr/adapter.rb

@@ -0,0 +1,6 @@
+module RSolr::Adapter
+  
+  autoload :Direct, 'rsolr/adapter/direct'
+  autoload :HTTP, 'rsolr/adapter/http'
+  
+end

data/lib/rsolr/adapter/direct.rb

@@ -0,0 +1,86 @@
+raise "JRuby Required" unless defined?(JRUBY_VERSION)
+
+require 'java'
+
+#
+# Connection for JRuby + DirectSolrConnection
+#
+class RSolr::Adapter::Direct
+  
+  include RSolr::HTTPClient::Util
+  
+  attr_accessor :opts, :home_dir
+  
+  # required: opts[:home_dir] is absolute path to solr home (the directory with "data", "config" etc.)
+  # opts must also contain either
+  #   :dist_dir => 'absolute path to solr distribution root
+  # or
+  #   :jar_paths => ['array of directories containing the solr lib/jars']
+  # OTHER OPTS:
+  #   :select_path => 'the/select/handler'
+  #   :update_path => 'the/update/handler'
+  def initialize(opts, &block)
+    @home_dir = opts[:home_dir].to_s
+    opts[:data_dir] ||= File.join(@home_dir, 'data')
+    if opts[:dist_dir] and ! opts[:jar_paths]
+      # add the standard lib and dist directories to the :jar_paths
+      opts[:jar_paths] = [File.join(opts[:dist_dir], 'lib'), File.join(opts[:dist_dir], 'dist')]
+    end
+    @opts = opts
+  end
+  
+  # loads/imports the java dependencies
+  # sets the @connection instance variable
+  def connection
+    @connection ||= (
+      require_jars(@opts[:jar_paths]) if @opts[:jar_paths]
+      import_dependencies
+      DirectSolrConnection.new(@home_dir, @opts[:data_dir], nil)
+    )
+  end
+  
+  def close
+    if @connection
+      @connection.close
+      @connection=nil
+    end
+  end
+  
+  # send a request to the connection
+  # request '/update', :wt=>:xml, '</commit>'
+  def send_request(path, params={}, data=nil)
+    data = data.to_xml if data.respond_to?(:to_xml)
+    url = build_url(path, params)
+    begin
+      body = connection.request(url, data)
+    rescue
+      raise RSolr::RequestError.new($!.message)
+    end
+    {
+      :status_code=>nil,
+      :body=>body,
+      :url=>url,
+      :path=>path,
+      :params=>params,
+      :data=>data,
+      :headers=>nil
+    }
+  end
+  
+  protected
+  
+  # do the java import thingy
+  def import_dependencies
+    import org.apache.solr.servlet.DirectSolrConnection
+  end
+  
+  # require the jar files
+  def require_jars(paths)
+    paths = [paths] unless paths.is_a?(Array)
+    paths.each do |path|
+      jar_pattern = File.join(path,"**", "*.jar")
+      Dir[jar_pattern].each {|jar_file| require jar_file}
+    end
+  end
+  
+end

data/lib/rsolr/adapter/http.rb

@@ -0,0 +1,44 @@
+#
+# Connection for standard HTTP Solr server
+#
+class RSolr::Adapter::HTTP
+  
+  attr_reader :opts, :connector, :connection
+  
+  # opts can have:
+  #   :url => 'http://localhost:8080/solr'
+  #   :select_path => '/the/url/path/to/the/select/handler'
+  #   :update_path => '/the/url/path/to/the/update/handler'
+  #   :luke_path => '/admin/luke'
+  #
+  def initialize(opts={}, &block)
+    opts[:url]||='http://127.0.0.1:8983/solr'
+    @opts = opts
+    @connector = RSolr::HTTPClient::Connector.new
+  end
+  
+  def connection
+    @connection ||= @connector.connect(@opts[:url])
+  end
+  
+  # send a request to the connection
+  # request '/update', :wt=>:xml, '</commit>'
+  def send_request(path, params={}, data=nil)
+    data = data.to_xml if data.respond_to?(:to_xml)
+    if data
+      http_context = connection.post(path, data, params, post_headers)
+    else
+      http_context = connection.get(path, params)
+    end
+    raise RSolr::RequestError.new(http_context[:body]) unless http_context[:status_code] == 200
+    http_context
+  end
+  
+  protected
+  
+  # The standard post headers
+  def post_headers
+    {"Content-Type" => 'text/xml; charset=utf-8'}
+  end
+  
+end

data/lib/rsolr/connection.rb

@@ -0,0 +1,107 @@
+class RSolr::Connection
+  
+  attr_reader :adapter, :opts
+  
+  # "adapter" is instance of:
+  #   RSolr::Adapter::HTTP
+  #   RSolr::Adapter::Direct (jRuby only)
+  def initialize(adapter, opts={})
+    @adapter = adapter
+    @opts = opts
+  end
+  
+  # send a request to the "select" handler
+  def select(params, &blk)
+    send_request('/select', map_params(params), &blk)
+  end
+  
+  # sends data to the update handler
+  # data can be a string of xml, or an object that returns xml from its #to_s method
+  def update(data, params={}, &blk)
+    send_request('/update', map_params(params), data, &blk)
+  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  
+  # 
+  # use a block to get access to the adapter response:
+  # solr.send_request('/select', :q=>'blue') do |solr_response, adapter_response|
+  #   raise 'Woops!' if adapter_response[:status] != 200
+  #   solr_response[:response][:docs].each {|doc|}
+  # end
+  #
+  def send_request(path, params={}, data=nil, &blk)
+    response = @adapter.send_request(path, map_params(params), data)
+    adapt_response(response, &blk)
+  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
+  
+  protected
+  
+  # shortcut to solr::message
+  def message
+    RSolr::Message
+  end
+  
+  # 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
+  
+  # 
+  def adapt_response(adapter_response)
+    if adapter_response[:params][:wt] == :ruby
+      data = Kernel.eval(adapter_response[:body]).to_mash
+    else
+      data = adapter_response[:body]
+    end
+    block_given? ? yield(data, adapter_response) : data
+  end
+  
+end