mwmitchell-solr 0.5.0

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

@@ -0,0 +1,56 @@
+module Solr::Mapper
+  
+  autoload :RSS, 'solr/mapper/rss'
+  
+  class UnkownMappingValue < RuntimeError; end
+  
+  class Base
+    
+    attr_reader :mapping, :opts
+  
+    def initialize(mapping={}, opts={}, &block)
+      @mapping = mapping
+      @opts = opts
+      yield @mapping if block_given?
+    end
+    
+    # source - a hash or array of source data
+    # override_mapping - an alternate mapper
+    # returns an array with one or more mapped hashes
+    def map(source, override_mapping=nil)
+      source = [source] if source.is_a?(Hash)
+      m = override_mapping || @mapping
+      source.collect do |src|
+        m.inject({}) do |mapped_data, (field_name, mapped_value)|
+          value = mapped_field_value(src, mapped_value)
+          value.to_s.empty? ? mapped_data : mapped_data.merge!({field_name=>value})
+        end
+      end
+    end
+  
+    protected
+  
+    # This is a hook method useful for subclassing
+    def source_field_value(source, field_name)
+      source[field_name]
+    end
+  
+    def mapped_field_value(source, mapped_value)
+      case mapped_value
+        when String
+          mapped_value
+        when Symbol
+          source_field_value(source, mapped_value)
+        when Proc
+          mapped_value.call(source, self)
+        when Enumerable
+          mapped_value.collect {|key| source_field_value(source, key)}.flatten
+        else
+          # try to turn it into a string, else raise UnkownMappingValue
+          mapped_value.respond_to?(:to_s) ? mapped_value.to_s : raise(UnkownMappingValue.new(mapped_value))
+      end
+    end
+    
+  end
+  
+end

data/lib/solr/mapper/rss.rb

@@ -0,0 +1,27 @@
+require 'rss'
+require 'open-uri'
+
+class Solr::Mapper::RSS < Solr::Mapper::Base
+  
+  attr_reader :rss
+  
+  # rss_file_or_url is file path or url (see open-uri)
+  # override_mapping is an alternate mapping (see Solr::Mapper::Base)
+  # returns array of mapped hashes
+  def map(rss_file_or_url, override_mapping=nil)
+    open(rss_file_or_url) do |feed|
+       @rss = RSS::Parser.parse(feed.read, false)
+       super(rss.items.collect, override_mapping)
+    end
+  end
+  
+  # sends methods chain down into the @rss object
+  # example: :'channel.title' == @rss.channel.title
+  # if the method chain doesn't exist, the super #source_field_value method is called
+  def source_field_value(source, method_path)
+    method_path.to_s.split('.').inject(@rss) do |rss, m|
+      rss.respond_to?(m) ? rss.send(m.to_sym) : super(source, method_path)
+    end
+  end
+  
+end

data/lib/solr/message.rb

@@ -0,0 +1,69 @@
+
+# http://builder.rubyforge.org/
+require 'rubygems'
+require 'builder'
+
+class Solr::Message
+  
+  class << self
+    
+    def xml
+      Builder::XmlMarkup.new
+    end
+    
+    # add({})
+    # add([{}, {}])
+    # add(docs) do |doc|
+    #   doc.boost = 10.0
+    # end
+    def add(data, opts={}, &block)
+      data = [data] if data.respond_to?(:each_pair) # if it's a hash, put it in an array
+      xml.add(opts) do |add_xml|
+        data.each do |item|
+          add_xml.doc do |doc_xml|
+            # convert keys into strings and perform an alpha sort (easier testing between ruby and jruby)
+            # but probably not great for performance? whatever...
+            sorted_items = item.inject({}) {|acc,(k,v)| acc.merge({k.to_s=>v})}
+            sorted_items.keys.sort.each do |k|
+              doc_attrs = {:name=>k}
+              yield doc_attrs if block_given?
+              doc_xml.field(sorted_items[k], doc_attrs)
+            end
+          end
+        end
+      end
+    end
+    
+    def commit(opts={})
+      xml.commit(opts)
+    end
+    
+    def optimize(opts={})
+      xml.optimize(opts)
+    end
+    
+    def rollback
+      xml.rollback
+    end
+    
+    def delete_by_id(ids)
+      ids = [ids] unless ids.is_a?(Array)
+      xml.delete do |xml|
+        ids.each do |id|
+          xml.id(id)
+        end
+      end
+    end
+    
+    def delete_by_query(queries)
+      queries = [queries] unless queries.is_a?(Array)
+      xml.delete do |xml|
+        queries.each do |query|
+          xml.query(query)
+        end
+      end
+    end
+    
+  end
+  
+end

data/lib/solr/response.rb

@@ -0,0 +1,143 @@
+module Solr::Response
+  
+  # default/base response object
+  class Base
+    
+    attr_reader :raw_response, :data, :header, :params, :status, :query_time
+    
+    def initialize(data)
+      if data.is_a?(String)
+        @raw_response = data
+        @data = Kernel.eval(@raw_response)
+      else
+        @data = data
+      end
+      @header = @data['responseHeader']
+      @params = @header['params']
+      @status = @header['status']
+      @query_time = @header['QTime']
+    end
+    
+    def ok?
+      self.status==0
+    end
+    
+  end
+  
+=begin
+  class Document
+    
+    attr_reader :data
+    
+    def initialize(source_hash)
+      source_hash.each do |k,v|
+        @data[k.to_sym]=v
+        instance_eval <<-EOF
+          def #{k}
+            @data[:#{k}]
+          end
+        EOF
+      end
+    end
+    
+    #
+    # doc.has?(:location_facet, 'Clemons')
+    # doc.has?(:id, 'h009', /^u/i)
+    #
+    def has?(k, *values)
+      return if @data[k].nil?
+      target = @data[k]
+      if target.is_a?(Array)
+        values.each do |val|
+          return target.any?{|tv| val.is_a?(Regexp) ? (tv =~ val) : (tv==val)}
+        end
+      else
+        return values.any? {|val| val.is_a?(Regexp) ? (target =~ val) : (target == val)}
+      end
+    end
+
+    #
+    def get(key, default=nil)
+      @data[key] || default
+    end
+    
+  end
+=end
+  
+  # response for queries
+  class Query < Base
+    
+    attr_reader :response, :docs, :num_found, :start
+    
+    alias :total :num_found
+    alias :offset :start
+    
+    def initialize(data)
+      super(data)
+      @response = @data['response']
+      @docs = @response['docs']
+      @num_found = @response['numFound']
+      @start = @response['start']
+    end
+    
+    def per_page
+      @per_page = params['rows'].to_s.to_i
+    end
+
+    def current_page
+      @current_page = self.per_page > 0 ? ((self.start / self.per_page).ceil) : 1
+      @current_page == 0 ? 1 : @current_page
+    end
+
+    alias :page :current_page
+
+    def page_count
+      @page_count = self.per_page > 0 ? (self.total / self.per_page.to_f).ceil : 1
+    end
+
+    # supports WillPaginate
+    alias :total_pages :page_count
+
+    alias :pages :page_count
+
+    # supports WillPaginate
+    def previous_page
+      (current_page > 1) ? current_page - 1 : 1
+    end
+
+    # supports WillPaginate
+    def next_page
+      (current_page < page_count) ? current_page + 1 : page_count
+    end
+    
+  end
+  
+  # response class for update requests
+  class Update < Base
+    
+  end
+  
+  # response for /admin/luke
+  class IndexInfo < Base
+    
+    attr_reader :index, :directory, :has_deletions, :optimized, :current, :max_doc, :num_docs, :version
+    
+    alias :has_deletions? :has_deletions
+    alias :optimized? :optimized
+    alias :current? :current
+    
+    def initialize(data)
+      super(data)
+      @index = @data['index']
+      @directory = @data['directory']
+      @has_deletions = @index['hasDeletions']
+      @optimized = @index['optimized']
+      @current = @index['current']
+      @max_doc = @index['maxDoc']
+      @num_docs = @index['numDocs']
+      @version = @index['version']
+    end
+    
+  end
+  
+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