mwmitchell-solr-ruby 0.5.0

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

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/indexer.rb

@@ -0,0 +1,23 @@
+class Solr::Indexer
+  
+  attr_reader :solr, :mapper, :opts
+  
+  def initialize(solr, mapping_or_mapper, opts={})
+    @solr = solr
+    @mapper = mapping_or_mapper.is_a?(Hash) ? Solr::Mapper::Base.new(mapping_or_mapper) : mapping_or_mapper
+    @opts = opts
+  end
+  
+  # data - the raw data to send into the mapper
+  # params - url query params for solr /update handler
+  # commit - boolean; true==commit after adding, false==no commit after adding
+  # block can be used for modifying the "add", "doc" and "field" xml elements (for boosting etc.)
+  def index(data, params={}, &block)
+    docs = data.collect {|d| @mapper.map(d)}
+    @solr.add(docs, params) do |add, doc, field|
+      # check opts for :debug etc.?
+      yield add, doc, field if block_given?
+    end
+  end
+  
+end

data/lib/solr.rb

@@ -0,0 +1,36 @@
+# 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 Solr
+  
+  VERSION = '0.5.0'
+  
+  autoload :Adapter, 'solr/adapter'
+  autoload :Message, 'solr/message'
+  autoload :Response, 'solr/response'
+  autoload :Connection, 'solr/connection'
+  autoload :Ext, 'solr/ext'
+  autoload :Mapper, 'solr/mapper'
+  autoload :Indexer, 'solr/indexer'
+  
+  # factory for creating connections
+  # adapter name is either :http or :direct
+  # adapter_opts are sent to the adapter instance (:url for http, :dist_dir for :direct etc.)
+  # connection_opts are sent to the connection instance (:auto_commit etc.)
+  def self.connect(adapter_name, adapter_opts={}, wrapper_opts={})
+    types = {
+      :http=>'HTTP',
+      :direct=>'Direct'
+    }
+    adapter_class_name = "Solr::Adapter::#{types[adapter_name]}"
+    adapter_class = Kernel.eval adapter_class_name
+    Solr::Connection::Base.new(adapter_class.new(adapter_opts), wrapper_opts)
+  end
+  
+  class RequestError < RuntimeError; end
+  
+end

data/solr-ruby.gemspec

@@ -0,0 +1,50 @@
+Gem::Specification.new do |s|
+  s.name = "solr-ruby"
+  s.version = "0.5.0"
+  s.date = "2008-12-16"
+  s.summary = "Ruby client for Apache Solr"
+  s.email = "goodieboy@gmail.com"
+  s.homepage = "http://github.com/mwmitchell/solr-ruby"
+  s.description = "solr-ruby is a Ruby gem for working with Apache Solr"
+  s.has_rdoc = true
+  s.authors = ["Matt Mitchell"]
+  s.files = [
+    "examples/http.rb",
+    "examples/direct.rb",
+    "lib/solr.rb",
+    "lib/core_ext.rb",
+    "lib/solr/adapter.rb",
+    "lib/solr/adapter/common_methods.rb",
+    "lib/solr/adapter/direct.rb",
+    "lib/solr/adapter/http.rb",
+    "lib/solr/connection.rb",
+    "lib/solr/connection/base.rb",
+    "lib/solr/connection/search_ext.rb",
+    "lib/solr/indexer.rb",
+    "lib/mapper.rb",
+    "lib/mapper/rss.rb",
+    "lib/message.rb",
+    "lib/response.rb",
+    "LICENSE",
+    "Rakefile",
+    "README.rdoc",
+    "solr-ruby.gemspec"
+  ]
+  s.test_files = [
+    "test/adapter_common_methods_test.rb",
+    "test/connection_test_methods.rb",
+    "test/direct_test.rb",
+    "test/ext_pagination_test.rb",
+    "test/ext_params_test.rb",
+    "test/ext_search_test.rb",
+    "test/http_test.rb",
+    "test/indexer_test.rb",
+    "test/mapper_test.rb",
+    "test/message_test.rb",
+    "test/ruby-lang.org.rss.xml",
+    "test/test_helpers.rb",
+  ]
+  s.rdoc_options = ["--main", "README.rdoc"]
+  s.extra_rdoc_files = []
+  s.add_dependency("builder", [">= 2.1.2"])
+end

data/test/adapter_common_methods_test.rb

@@ -0,0 +1,49 @@
+require File.join(File.dirname(__FILE__), 'test_helpers')
+
+class AdapterCommonMethodsTest < Test::Unit::TestCase
+  
+  class DummyClass
+    include Solr::Adapter::CommonMethods
+  end
+  
+  def setup
+    @c = DummyClass.new
+  end
+  
+  def test_default_options
+    target = {
+      :select_path => '/select',
+      :update_path => '/update',
+      :luke_path => '/admin/luke'
+    }
+    assert_equal target, @c.default_options
+  end
+  
+  def test_build_url
+    m = @c.method(:build_url)
+    assert_equal '/something', m.call('/something')
+    assert_equal '/something?q=Testing', m.call('/something', :q=>'Testing')
+    assert_equal '/something?array=1&array=2&array=3', m.call('/something', :array=>[1, 2, 3])
+    assert_equal '/something?array=1&array=2&array=3&q=A', m.call('/something', :q=>'A', :array=>[1, 2, 3])
+  end
+  
+  def test_escape
+    assert_equal '%2B', @c.escape('+')
+    assert_equal 'This+is+a+test', @c.escape('This is a test')
+    assert_equal '%3C%3E%2F%5C', @c.escape('<>/\\')
+    assert_equal '%22', @c.escape('"')
+    assert_equal '%3A', @c.escape(':')
+  end
+  
+  def test_hash_to_params
+    my_params = {
+      :z=>'should be last',
+      :q=>'test',
+      :d=>[1, 2, 3, 4],
+      :b=>:zxcv,
+      :x=>['!', '*', nil]
+    }
+    assert_equal 'b=zxcv&d=1&d=2&d=3&d=4&q=test&x=%21&x=%2A&z=should+be+last', @c.hash_to_params(my_params)
+  end
+  
+end

data/test/connection_test_methods.rb

@@ -0,0 +1,82 @@
+# These are all of the test methods used by the various connection + adapter tests
+# Currently: Direct and HTTP
+# By sharing these tests, we can make sure the adapters are doing what they're suppossed to
+# while staying "dry"
+
+module ConnectionTestMethods
+  
+  def teardown
+    response = @solr.delete_by_query('id:[* TO *]')
+    assert_equal 0, @solr.query(:q=>'*:*').docs.size
+  end
+  
+  # setting adapter options in Solr.connect method should set them in the adapter
+  def test_set_adapter_options
+    solr = Solr.connect(:http, :select_path=>'/select2')
+    assert_equal '/select2', solr.adapter.opts[:select_path]
+  end
+  
+  # setting connection options in Solr.connect method should set them in the connection
+  def test_set_connection_options
+    solr = Solr.connect(:http, {}, :default_wt=>:json)
+    assert_equal :json, solr.opts[:default_wt]
+  end
+  
+  # If :wt is NOT :ruby, the format doesn't get wrapped in a Solr::Response class
+  # Raw ruby can be returned by using :wt=>'ruby', not :ruby
+  def test_raw_response_formats
+    ruby_response = @solr.query(:q=>'*:*', :wt=>'ruby')
+    assert ruby_response.is_a?(String)
+    assert ruby_response=~%r('wt'=>'ruby')
+    # xml?
+    xml_response = @solr.query(:q=>'*:*', :wt=>'xml')
+    assert xml_response=~%r(<str name="wt">xml</str>)
+    # json?
+    json_response = @solr.query(:q=>'*:*', :wt=>'json')
+    assert json_response=~%r("wt":"json")
+  end
+  
+  def test_query_responses
+    r = @solr.query(:q=>'*:*')
+    assert r.is_a?(Solr::Response::Query)
+    # catch exceptions for bad queries
+    assert_raise Solr::RequestError do
+      @solr.query(:q=>'!')
+    end
+  end
+  
+  def test_add
+    assert_equal 0, @solr.query(:q=>'*:*').total
+    response = @solr.add(:id=>100)
+    assert_equal 1, @solr.query(:q=>'*:*').total
+    assert response.is_a?(Solr::Response::Update)
+  end
+  
+  def test_delete_by_id
+    @solr.add(:id=>100)
+    total = @solr.query(:q=>'*:*').total
+    assert_equal 1, total
+    delete_response = @solr.delete_by_id(100)
+    assert delete_response.is_a?(Solr::Response::Update)
+    total = @solr.query(:q=>'*:*').total
+    assert_equal 0, total
+  end
+  
+  def test_delete_by_query
+    @solr.add(:id=>1, :name=>'BLAH BLAH BLAH')
+    assert_equal 1, @solr.query(:q=>'*:*').total
+    response = @solr.delete_by_query('name:BLAH BLAH BLAH')
+    assert response.is_a?(Solr::Response::Update)
+    assert_equal 0, @solr.query(:q=>'*:*').total
+  end
+  
+  def test_index_info
+    response = @solr.index_info
+    assert response.is_a?(Solr::Response::IndexInfo)
+    # make sure the ? methods are true/false
+    assert [true, false].include?(response.current?)
+    assert [true, false].include?(response.optimized?)
+    assert [true, false].include?(response.has_deletions?)
+  end
+  
+end

data/test/direct_test.rb

@@ -0,0 +1,20 @@
+if defined?(JRUBY_VERSION)
+
+require File.join(File.dirname(__FILE__), 'test_helpers')
+
+require 'connection_test_methods'
+
+class DirectTest < Test::Unit::TestCase
+  
+  include ConnectionTestMethods
+  
+  def setup
+    base = File.expand_path( File.dirname(__FILE__) )
+    dist = File.join(base, '..', 'apache-solr')
+    home = File.join(dist, 'example', 'solr')
+    @solr = Solr.connect(:direct, {:home_dir=>home, :dist_dir=>dist}, :auto_commit=>true)
+  end
+  
+end
+
+end

data/test/ext_pagination_test.rb

@@ -0,0 +1,58 @@
+require File.join(File.dirname(__FILE__), 'test_helpers')
+
+class ExtPaginationTest < Test::Unit::TestCase
+  
+  def create_response(params={})
+    response = Solr::Response::Query.new(mock_query_response)
+    response.params.merge! params
+    response
+  end
+  
+  # test the Solr::Connection pagination methods
+  def test_connection_calculate_start
+    dp = Solr::Connection::Base.new(nil)
+    assert_equal 15, dp.send(:calculate_start, 2, 15)
+    assert_equal 450, dp.send(:calculate_start, 10, 50)
+    assert_equal 0, dp.send(:calculate_start, 0, 50)
+  end
+  
+  def test_connection_modify_params_for_pagination
+    dp = Solr::Connection::Base.new(nil)
+    p = dp.send(:modify_params_for_pagination, {:page=>1})
+    assert_equal 0, p[:start]
+    assert_equal 10, p[:rows]
+    #
+    p = dp.send(:modify_params_for_pagination, {:page=>10, :per_page=>100})
+    assert_equal 900, p[:start]
+    assert_equal 100, p[:rows]
+  end
+  
+  def test_math
+    response = create_response({'rows'=>5})
+    assert_equal response.params['rows'], response.per_page
+    assert_equal 26, response.total
+    assert_equal 1, response.current_page
+    assert_equal 6, response.page_count
+    
+    # now switch the rows (per_page)
+    # total and current page should remain the same value
+    # page_count should change
+    
+    response = create_response({'rows'=>2})
+    assert_equal response.params['rows'], response.per_page
+    assert_equal 26, response.total
+    assert_equal 1, response.current_page
+    assert_equal 13, response.page_count
+    
+    # now switch the start
+    
+    response = create_response({'rows'=>3})
+    response.instance_variable_set '@start', 4
+    assert_equal response.params['rows'], response.per_page
+    assert_equal 26, response.total
+    # 2 per page, currently on the 10th item
+    assert_equal 1, response.current_page
+    assert_equal 9, response.page_count
+  end
+  
+end

data/test/ext_search_test.rb

@@ -0,0 +1,9 @@
+require File.join(File.dirname(__FILE__), 'test_helpers')
+
+class ExtSearchTest < Test::Unit::TestCase
+  
+  def test_mapping_methods
+    
+  end
+  
+end

data/test/http_test.rb

@@ -0,0 +1,13 @@
+require File.join(File.dirname(__FILE__), 'test_helpers')
+
+require 'connection_test_methods'
+
+class HTTPTest < Test::Unit::TestCase
+  
+  include ConnectionTestMethods
+  
+  def setup
+    @solr = Solr.connect(:http, {}, :auto_commit=>true)
+  end
+  
+end

data/test/indexer_test.rb

@@ -0,0 +1,14 @@
+require File.join(File.dirname(__FILE__), 'test_helpers')
+
+class IndexerTest < Test::Unit::TestCase
+  
+  def test_something
+    data = nil
+    mapping = {
+      
+    }
+    i = Solr::Indexer.new(Solr.connect(:http), mapping)
+    i.index([])
+  end
+  
+end