mwmitchell-rsolr 0.5.7

data/examples/direct.rb

@@ -0,0 +1,20 @@
+# Must be executed using jruby
+require File.join(File.dirname(__FILE__), '..', 'lib', 'rsolr')
+
+base = File.expand_path( File.dirname(__FILE__) )
+dist = File.join(base, '..', 'apache-solr')
+home = File.join(dist, 'example', 'solr')
+
+solr = RSolr.connect(:direct, :home_dir=>home, :dist_dir=>dist)
+
+`cd ../apache-solr/example/exampledocs && ./post.sh ./*.xml`
+
+response = solr.search 'ipod', :filters=>{:price=>(0..50)}, :per_page=>2, :page=>1
+
+solr.delete_by_query('*:*')
+
+response.docs.each do |doc|
+  if doc.has?('timestamp')
+    puts doc.timestamp
+  end
+end

data/examples/http.rb

@@ -0,0 +1,16 @@
+# Must be executed using jruby
+require File.join(File.dirname(__FILE__), '..', 'lib', 'rsolr')
+
+solr = RSolr.connect(:http)
+
+`cd ../apache-solr/example/exampledocs && ./post.sh ./*.xml`
+
+response = solr.search 'ipod', :filters=>{:price=>(0..50)}, :per_page=>2, :page=>1
+
+solr.delete_by_query('*:*')
+
+response.docs.each do |doc|
+  if doc.has?('timestamp')
+    puts doc.timestamp
+  end
+end

data/lib/core_ext.rb

@@ -0,0 +1,8 @@
+class Symbol
+  
+  # allow symbol chaining: :one.two.three
+  def method_missing(m)
+    [self.to_s, m.to_s].join('.').to_sym
+  end
+  
+end

data/lib/rsolr.rb

@@ -0,0 +1,34 @@
+# 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'])
+
+module RSolr
+  
+  VERSION = '0.5.7'
+  
+  autoload :Message, 'rsolr/message'
+  autoload :Response, 'rsolr/response'
+  autoload :Connection, 'rsolr/connection'
+  autoload :Mapper, 'rsolr/mapper'
+  autoload :Indexer, 'rsolr/indexer'
+  autoload :HTTPClient, 'rsolr/http_client'
+  
+  # factory for creating connections
+  # adapter name is either :http or :direct
+  # opts are sent to the adapter instance (:url for http, :dist_dir for :direct etc.)
+  # and to the connection instance
+  def self.connect(adapter_name, opts={})
+    types = {
+      :http=>'HTTP',
+      :direct=>'Direct'
+    }
+    adapter_class = RSolr::Connection::Adapter.const_get(types[adapter_name])
+    RSolr::Connection::Base.new(adapter_class.new(opts), opts)
+  end
+  
+  class RequestError < RuntimeError; end
+  
+end

data/lib/rsolr/connection.rb

@@ -0,0 +1,7 @@
+module RSolr::Connection
+  
+  autoload :Base, 'rsolr/connection/base'
+  autoload :SearchExt, 'rsolr/connection/search_ext'
+  autoload :Adapter, 'rsolr/connection/adapter'
+  
+end

data/lib/rsolr/connection/adapter.rb

@@ -0,0 +1,7 @@
+module RSolr::Connection::Adapter
+  
+  autoload :Direct, 'rsolr/connection/adapter/direct'
+  autoload :HTTP, 'rsolr/connection/adapter/http'
+  autoload :CommonMethods, 'rsolr/connection/adapter/common_methods'
+  
+end

data/lib/rsolr/connection/adapter/common_methods.rb

@@ -0,0 +1,46 @@
+# This module is for HTTP + DirectSolrConnection (jruby) connections
+# It provides common methods.
+# The main query, update and index_info methods are here
+# The classes that include this module only need to provide a request method like:
+#   send_request(request_path, params, data)
+# where:
+#   request_path is a string to a handler (/select)
+#   params is a hash for query string params
+#   data is optional string of xml
+module RSolr::Connection::Adapter::CommonMethods
+  
+  # send a request to the "select" handler
+  def query(params)
+    send_request @opts[:select_path], params
+  end
+  
+  # sends data to the update handler
+  # data can be:
+  #   string (valid solr update xml)
+  #   object with respond_to?(:to_xml)
+  # params is a hash with valid solr update params
+  def update(data, params={})
+    send_request @opts[:update_path], params, data
+  end
+  
+  # sends a request to the admin luke handler to get info on the index
+  def index_info(params={})
+    params[:numTerms]||=0
+    send_request @opts[:luke_path], params
+  end
+  
+  def default_options
+    {
+      :select_path => '/select',
+      :update_path => '/update',
+      :luke_path => '/admin/luke'
+    }
+  end
+  
+  # send a request to the adapter (allows requests like /admin/luke etc.)
+  def send_request(handler_path, params={}, data=nil)
+    params = map_params(params)
+    @adapter.send_request(handler_path, params, data)
+  end
+  
+end

data/lib/rsolr/connection/adapter/direct.rb

@@ -0,0 +1,80 @@
+raise "JRuby Required" unless defined?(JRUBY_VERSION)
+
+require 'java'
+
+#
+# Connection for JRuby + DirectSolrConnection
+#
+class RSolr::Connection::Adapter::Direct
+  
+  include RSolr::HTTPClient::Util
+  include RSolr::Connection::Adapter::CommonMethods
+  
+  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]
+      # 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 = default_options.merge(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
+  
+  # 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=>'',
+      :body=>body,
+      :url=>url,
+      :path=>path,
+      :params=>params,
+      :data=>data,
+      :headers=>{}
+    }
+  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/connection/adapter/http.rb

@@ -0,0 +1,51 @@
+#
+# Connection for standard HTTP Solr server
+#
+class RSolr::Connection::Adapter::HTTP
+  
+  class << self
+    attr_accessor :client_adapter
+  end
+  
+  @client_adapter = :net_http
+  
+  include RSolr::Connection::Adapter::CommonMethods
+  
+  attr_reader :opts
+  
+  # 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 = default_options.merge(opts)
+  end
+  
+  def connection
+    @connection ||= RSolr::HTTPClient.connect(@opts[:url], self.class.client_adapter)
+  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/base.rb

@@ -0,0 +1,121 @@
+#
+# Connection adapter decorator
+#
+class RSolr::Connection::Base
+  
+  attr_reader :adapter, :opts
+  
+  include RSolr::Connection::SearchExt
+  
+  # "adapter" is instance of:
+  #   RSolr::Adapter::HTTP
+  #   RSolr::Adapter::Direct (jRuby only)
+  def initialize(adapter, opts={})
+    @adapter=adapter
+    opts[:global_params]||={}
+    default_global_params = {
+      :wt=>:ruby,
+      :echoParams=>'EXPLICIT',
+      :debugQuery=>true
+    }
+    opts[:global_params] = default_global_params.merge(opts[:global_params])
+    @opts=opts
+  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)
+    opts[:global_params].dup.merge(params).dup
+  end
+  
+  # send request to the select handler
+  # params is hash with valid solr request params (:q, :fl, :qf etc..)
+  #   if params[:wt] is not set, the default is :ruby (see opts[:global_params])
+  #   if :wt is something other than :ruby, the raw response body is returned
+  #   otherwise, an instance of RSolr::Response::Query is returned
+  #   NOTE: to get raw ruby, use :wt=>'ruby'
+  def query(params)
+    params = map_params(modify_params_for_pagination(params))
+    response = @adapter.query(params)
+    params[:wt]==:ruby ? RSolr::Response::Query::Base.new(response) : response
+  end
+  
+  # Finds a document by its id
+  def find_by_id(id, params={})
+    params = map_params(params)
+    params[:q] = 'id:"#{id}"'
+    query params
+  end
+  
+  def index_info(params={})
+    params = map_params(params)
+    response = @adapter.index_info(params)
+    params[:wt] == :ruby ? RSolr::Response::IndexInfo.new(response) : response
+  end
+  
+  # if :ruby is the :wt, then Solr::Response::Base is returned
+  # -- there's not really a way to figure out what kind of handler request this is.
+  
+  def update(data, params={})
+    params = map_params(params)
+    response = @adapter.update(data, params)
+    params[:wt]==:ruby ? RSolr::Response::Update.new(response) : response
+  end
+  
+  def add(hash_or_array, opts={}, &block)
+    update message.add(hash_or_array, opts, &block)
+  end
+  
+  # send </commit>
+  def commit(opts={})
+    update message.commit, opts
+  end
+  
+  # send </optimize>
+  def optimize(opts={})
+    update message.optimize, opts
+  end
+  
+  # send </rollback>
+  # NOTE: solr 1.4 only
+  def rollback(opts={})
+    update message.rollback, opts
+  end
+  
+  # Delete one or many documents by id
+  #   solr.delete_by_id 10
+  #   solr.delete_by_id([12, 41, 199])
+  def delete_by_id(ids, opts={})
+    update message.delete_by_id(ids), opts
+  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(queries, opts={})
+    update message.delete_by_query(queries), opts
+  end
+  
+  protected
+  
+  # shortcut to solr::message
+  def message
+    RSolr::Message
+  end
+  
+  def modify_params_for_pagination(orig_params)
+    return orig_params unless orig_params[:page] || orig_params[:per_page]
+    params = orig_params.dup # be nice
+    params[:page] ||= 1
+    params[:per_page] ||= 10
+    params[:rows] = params.delete(:per_page).to_i
+    params[:start] = calculate_start(params.delete(:page).to_i, params[:rows])
+    params
+  end
+  
+  def calculate_start(current_page, per_page)
+    page = current_page > 0 ? current_page : 1
+    (page - 1) * per_page
+  end
+  
+end

data/lib/rsolr/connection/search_ext.rb

@@ -0,0 +1,126 @@
+module RSolr::Connection::SearchExt
+  
+  def search(q_param, params={})
+    if params[:fields]
+      fields = params.delete :fields
+      params[:fl] = fields.is_a?(Array) ? fields.join(' ') : fields
+    end
+    
+    # adds quoted values to the :filters hash
+    if params[:phrase_filters]
+      phrase_filters = params.delete(:phrase_filters)
+      params[:filters] ||= {}
+      phrase_filters.each do |filter,values|
+        params[:filters][filter] ||= []
+        values.each do |v|
+          params[:filters][filter] << "\"#{v}\""
+        end
+      end
+    end
+    
+    params[:fq] = build_filters(params.delete(:filters)) if params[:filters]
+    facets = params.delete(:facets) if params[:facets]
+    
+    if facets
+      if facets.is_a?(Array)
+        params.merge!({:facet => true})
+        params.merge! build_facets(facets)          
+      elsif facets.is_a?(Hash)
+        params.merge!({:facet => true})
+        #params += build_facet(facets)
+      elsif facets.is_a?(String)
+        #params += facets
+      else
+        raise 'facets must either be a Hash or an Array'
+      end
+    end
+    #params[:qt] ||= :dismax
+    params[:q] = build_query(q_param)
+    self.query params
+  end
+  
+  protected
+  
+  # returns the query param
+  def build_query(queries)
+    query_string = ''
+    case queries
+    when String
+      query_string = queries
+    when Array
+      query_string = queries.join(' ')
+    when Hash
+      query_string_array = []
+      queries.each do |k,v|
+        if v.is_a?(Array) # add a filter for each value
+          v.each do |val|
+            query_string_array << "#{k}:#{val}"
+          end
+        elsif v.is_a?(Range)
+          query_string_array << "#{k}:[#{v.min} TO #{v.max}]"
+        else
+          query_string_array << "#{k}:#{v}"
+        end
+      end
+      query_string = query_string_array.join(' ')
+    end
+    query_string
+  end
+
+  def build_filters(filters)
+    params = []
+    # handle "ruby-ish" filters
+    case filters
+    when String
+      params << filters
+    when Array
+      filters.each { |f| params << f }
+    when Hash
+      filters.each do |k,v|
+        if v.is_a?(Array) # add a filter for each value
+          v.each do |val|
+            params << "#{k}:#{val}"
+          end
+        elsif v.is_a?(Range)
+          params << "#{k}:[#{v.min} TO #{v.max}]"
+        else
+          params << "#{k}:#{v}"
+        end
+      end
+    end
+    params
+  end
+  
+  def build_facets(facet_array)
+    facet_array.inject({}) do |p, facet_hash|
+      build_facet(facet_hash).each {|k| p.merge!(k) }
+      p
+    end
+  end
+
+  def build_facet(facet_hash)
+    params = []
+    facet_name = facet_hash['name'] || facet_hash[:name]
+    facet_hash.each do |k,v|
+      # handle some cases specially
+      if 'field' == k.to_s
+        params << {"facet.field" => v}
+      elsif 'query' == k.to_s
+        q = build_query(v)
+        params << {"facet.query"=>q}
+        if facet_name
+          # keep track of names => facet_queries
+          name_to_facet_query[facet_name] = q['facet.query']
+        end
+      else
+        params << {"f.#{facet_hash[:field]}.facet.#{k}" => v}
+      end
+    end
+    params
+  end
+  
+  def name_to_facet_query
+    @name_to_facet_query ||= {}
+  end
+
+end