mwmitchell-solr 0.5.2 → 0.5.3

data/README.rdoc

@@ -9,7 +9,7 @@ To run tests:
   MRI Ruby:           rake
   JRuby:              jruby -S rake
 
-To get a connection in Ruby:
+To get a connection in MRI/standard Ruby:
   
   solr = Solr.connect(:http)
 
@@ -17,10 +17,9 @@ To get a direct connection in jRuby using DirectSolrConnection:
   
   solr = Solr.connect(:direct, :home_dir=>'/path/to/solr/home', :dist_dir=>'/path/to/solr/distribution')
 
-You can set global connection options like:
+You can set Solr params that will be sent for every request:
   
-  connection_opts = {:auto_commit=>false, :global_params=>{:wt=>:ruby, :echoParams=>'EXPLICIT'}}
-  solr = Solr.connect(:http, {}, connection_opts)
+  solr = Solr.connect(:http, :global_params=>{:wt=>:ruby, :echoParams=>'EXPLICIT'})
 
 Solr.connect also yields the adapter instance if a block is supplied:
   
@@ -47,8 +46,10 @@ Pagination is simplified by using the :page and :per_page params:
 
   response = solr.query(:page=>1, :per_page=>10, :q=>'*:*')
   response.per_page
-  response.page_count
+  response.total_pages
   response.current_page
+  response.previous_page
+  response.next_page
 
 If you use WillPaginate, just pass-in the response to the #will_paginate view helper:
   
@@ -88,4 +89,60 @@ Commit & Optimize
 
 
 ==Response Formats
-The default response format is Ruby. When the :wt param is set to :ruby, the response is eval'd and wrapped up in a nice Solr::Response class. You can get raw ruby by setting the :wt to "ruby" - notice, the string -- not a symbol. All other response formats are available as expected, :wt=>'xml' etc.. Currently, the only response format that gets eval'd and wrapped is :ruby.
+The default response format is Ruby. When the :wt param is set to :ruby, the response is eval'd and wrapped up in a nice Solr::Response class. You can get raw ruby by setting the :wt to "ruby" - notice, the string -- not a symbol. All other response formats are available as expected, :wt=>'xml' etc.. Currently, the only response format that gets eval'd and wrapped is :ruby.
+
+==Data Mapping
+The Solr::Mapper::Base class provides some nice ways of mapping data. You provide a hash mapping and a "data source". The keys of the hash mapping become the Solr field names. The values of the hash mapping get processed differently based on the type of value. The data source must be an Enumerable type object. The hash mapping is called for each item in the data source.
+
+===Hash Map Processing
+If the value is a string, the String is used as the final Solr field value. If the value is a Symbol, the Symbol is used as a key on the data source. An Enumerable type does the same as the Symbol, but for each item. The most interesting processing occurs when the value is a Proc. When a Proc is used as a hash mapping value, the Solr::Mapper::Base executes the Proc's #call method, passing in the current data source item.
+
+===Examples
+
+  mapping = {
+    :id=>:id,
+    :title=>:title,
+    :source=>'Example',
+    :meta=>[:author, :sub_title],
+    :web_id=>proc {|item|
+      WebService.fetch_item_id_by_name(item[:name])
+    }
+  }
+  
+  data_source = [
+    {
+      :id=>100,
+      :title=>'Doc One',
+      :author=>'Mr. X',
+      :sub_title=>'A first class document.',
+      :name=>'doc_1'
+    },
+    {
+      :id=>200,
+      :title=>'Doc Two',
+      :author=>'Mr. XYZ',
+      :sub_title=>'A second class document.',
+      :name=>'doc_2'
+    }
+  ]
+  
+  mapper = Solr::Mapper::Base(mapping)
+  mapped_data = mapper.map(data_source)
+  
+  # the following would be true...
+  mapped_data == [
+    {
+      :id=>100,
+      :title=>'Doc One',
+      :source=>'Example',
+      :meta=>['Mr. X', 'A first class document'],
+      :web_id=>'web_id_for_doc_1_for_example'
+    },
+    {
+      :id=>200,
+      :title=>'Doc Two',
+      :source=>'Example',
+      :meta=>['Mr. XYZ', 'A second class document'],
+      :web_id=>'web_id_for_doc_2_for_example'
+    }
+  ]

data/lib/solr/connection/base.rb

@@ -37,7 +37,7 @@ class Solr::Connection::Base
   def query(params)
     params = map_params(modify_params_for_pagination(params))
     response = @adapter.query(params)
-    params[:wt]==:ruby ? Solr::Response::Query.new(response) : response
+    params[:wt]==:ruby ? Solr::Response::Query::Base.new(response) : response
   end
   
   # Finds a document by its id

data/lib/solr/response.rb

@@ -1,143 +1,8 @@
 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
+  autoload :Base, 'solr/response/base'
+  autoload :Query, 'solr/response/query'
+  autoload :IndexInfo, 'solr/response/index_info'
+  autoload :Update, 'solr/response/update'
   
 end

data/lib/solr.rb

@@ -7,7 +7,7 @@ proc {|base, files|
 
 module Solr
   
-  VERSION = '0.5.2'
+  VERSION = '0.5.3'
   
   autoload :Adapter, 'solr/adapter'
   autoload :Message, 'solr/message'

data/test/connection_test_methods.rb

@@ -39,7 +39,7 @@ module ConnectionTestMethods
   
   def test_query_responses
     r = @solr.query(:q=>'*:*')
-    assert r.is_a?(Solr::Response::Query)
+    assert r.is_a?(Solr::Response::Query::Base)
     # catch exceptions for bad queries
     assert_raise Solr::RequestError do
       @solr.query(:q=>'!')

data/test/ext_pagination_test.rb

@@ -3,7 +3,7 @@ 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 = Solr::Response::Query::Base.new(mock_query_response)
     response.params.merge! params
     response
   end
@@ -32,7 +32,7 @@ class ExtPaginationTest < Test::Unit::TestCase
     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
+    assert_equal 6, response.total_pages
     
     # now switch the rows (per_page)
     # total and current page should remain the same value
@@ -42,7 +42,7 @@ class ExtPaginationTest < Test::Unit::TestCase
     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
+    assert_equal 13, response.total_pages
     
     # now switch the start
     
@@ -52,7 +52,7 @@ class ExtPaginationTest < Test::Unit::TestCase
     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
+    assert_equal 9, response.total_pages
   end
   
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mwmitchell-solr
 version: !ruby/object:Gem::Version 
-  version: 0.5.2
+  version: 0.5.3
 platform: ruby
 authors: 
 - Matt Mitchell