mwmitchell-solr 0.5.0

data/lib/solr/adapter/common_methods.rb

@@ -0,0 +1,89 @@
+# 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 Solr::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
+  
+  # escapes a query key/value for http
+  def escape(s)
+    s.to_s.gsub(/([^ a-zA-Z0-9_.-]+)/n) {
+      '%'+$1.unpack('H2'*$1.size).join('%').upcase
+    }.tr(' ', '+') 
+  end
+  
+  def build_param(k,v)
+    "#{escape(k)}=#{escape(v)}"
+  end
+  
+  # takes a path and a hash of query params, returns an escaped url with query params
+  def build_url(path, params_hash=nil)
+    query = hash_to_params(params_hash)
+    query ? path + '?' + query : path
+  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_params(:q=>'blah', 'facet.field'=>['location_facet', 'format_facet'])
+  # returns:
+  #   ?q=blah&facet.field=location_facet&facet.field=format.facet
+  #
+  # if a value is empty/nil etc., the key is not added
+  def hash_to_params(params)
+    return unless params.is_a?(Hash)
+    # copy params and convert keys to strings
+    params = params.inject({}){|acc,(k,v)| acc.merge({k.to_s, v}) }
+    # get sorted keys
+    params.keys.sort.inject([]) do |acc,k|
+      v = params[k]
+      if v.is_a?(Array)
+        acc << v.reject{|i|i.to_s.empty?}.collect{|vv|build_param(k, vv)}
+      elsif ! v.to_s.empty?
+        acc.push(build_param(k, v))
+      end
+      acc
+    end.join('&')
+  end
+  
+end

data/lib/solr/adapter/direct.rb

@@ -0,0 +1,65 @@
+raise "JRuby Required" unless defined?(JRUBY_VERSION)
+
+require 'java'
+
+#
+# Connection for JRuby + DirectSolrConnection
+#
+class Solr::Adapter::Direct
+  
+  include Solr::Adapter::CommonMethods
+  
+  attr_accessor :opts, :connection, :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'
+  # If a block is given, the @connection instance (DirectSolrConnection) is yielded
+  def initialize(opts, &block)
+    @home_dir = opts[:home_dir]
+    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)
+    require_jars(@opts[:jar_paths])
+    import_dependencies
+    @connection = DirectSolrConnection.new(@home_dir, @opts[:data_dir], nil)
+    yield @connection if block_given?
+  end
+  
+  # send a request to the connection
+  # request '/update', :wt=>:xml, '</commit>'
+  def send_request(request_url_path, params={}, data=nil)
+    data = data.to_xml if data.respond_to?(:to_xml)
+    full_path = build_url(request_url_path, params)
+    begin
+      @connection.request(full_path, data)
+    rescue
+      raise Solr::RequestError.new($!.message)
+    end
+  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/solr/adapter/http.rb

@@ -0,0 +1,55 @@
+require 'net/http'
+
+#
+# Connection for standard HTTP Solr server
+#
+class Solr::Adapter::HTTP
+  
+  include Solr::Adapter::CommonMethods
+  
+  attr_accessor :opts, :connection, :url
+  
+  # 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'
+  #
+  # If a block is given, the @connection (Net::HTTP) instance is yielded
+  def initialize(opts={}, &block)
+    opts[:url]||='http://127.0.0.1:8983/solr'
+    @url = URI.parse(opts[:url])
+    @connection = Net::HTTP.new(@url.host, @url.port)
+    yield @connection if block_given?
+    @opts = default_options.merge(opts)
+  end
+  
+  # send a request to the connection
+  # request '/update', :wt=>:xml, '</commit>'
+  def send_request(request_url_path, params={}, data=nil)
+    data = data.to_xml if data.respond_to?(:to_xml)
+    full_path = build_url(@url.path + request_url_path, params)
+    if data
+      response = @connection.post(full_path, data, post_headers)
+    else
+      response = @connection.get(full_path)
+    end
+    unless response.code=='200'
+      raise Solr::RequestError.new(parse_solr_html_error(response.body))
+    end
+    response.body
+  end
+  
+  protected
+  
+  # The standard post headers
+  def post_headers
+    {"Content-Type" => 'text/xml', 'charset'=>'utf-8'}
+  end
+  
+  # extracts the message from the solr error response
+  def parse_solr_html_error(html)
+    html.scan(/<pre>(.*)<\/pre>/mi).first.first.gsub(/&lt;/, '<').gsub(/&gt;/, '>') rescue html
+  end
+  
+end

data/lib/solr/connection.rb

@@ -0,0 +1,7 @@
+module Solr::Connection
+  
+  autoload :Base, 'solr/connection/base'
+  autoload :SearchExt, 'solr/connection/search_ext'
+  autoload :PaginationExt, 'solr/connection/pagination_ext'
+  
+end

data/lib/solr/connection/base.rb

@@ -0,0 +1,122 @@
+#
+# Connection adapter decorator
+#
+class Solr::Connection::Base
+  
+  attr_reader :adapter, :opts
+  
+  include Solr::Connection::SearchExt
+  
+  # conection is instance of:
+  #   Solr::Adapter::HTTP
+  #   Solr::Adapter::Direct (jRuby only)
+  def initialize(adapter, opts={})
+    @adapter=adapter
+    opts[:auto_commit]||=false
+    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 Solr::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 ? Solr::Response::Query.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 ? Solr::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={}, auto_commit=nil)
+    params = map_params(params)
+    response = @adapter.update(data, params)
+    self.commit if auto_commit.nil? ? @opts[:auto_commit]==true : auto_commit
+    params[:wt]==:ruby ? Solr::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, false
+  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
+    Solr::Message
+  end
+  
+  def modify_params_for_pagination(params)
+    return params unless params[:page]
+    params = params.dup # be nice
+    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/solr/connection/search_ext.rb

@@ -0,0 +1,110 @@
+module Solr::Connection::SearchExt
+  
+  def search(query, params={})
+    if params[:fields].is_a?(Array)
+      params[:fl] = params.delete(:fields).join(' ')
+    else
+      params[:fl] = params.delete :fields
+    end
+    fq = build_filters(params.delete(:filters)).join(' ') if params[:filters]
+    if params[:fq] and fq
+      params[:fq] += " AND #{fq}"
+    else
+      params[:fq] = fq
+    end
+    facets = params.delete(:facets) if params[:facets]
+    if facets
+      if facets.is_a?(Array)
+        params << {:facet => true}
+        params += build_facets(facets)          
+      elsif facets.is_a?(Hash)
+        params << {: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
+    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 |params, facet_hash|
+      params.push build_facet(facet_hash)
+    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("facet.query", v)
+        params << q
+      elsif ['name', :name].include?(k.to_s)
+        # do nothing
+      else
+        params << {"f.#{facet_hash[:field]}.facet.#{k}" => v}
+      end
+    end
+    params
+  end
+  
+end