mwmitchell-rsolr-ext 0.7.35 → 0.8.0

data/README.rdoc

@@ -14,12 +14,12 @@ A set of helper methods/modules to assist in building Solr queries and handling
   
   rsolr = RSolr::Ext.connect
   
-  response = rsolr.select(solr_params)
+  response = rsolr.find(solr_params)
 
 ==Response Example
   rsolr = RSolr::Ext.connect
   
-  response = rsolr.select(:q=>'*:*)
+  response = rsolr.find :q=>'*:*'
   
   response.ok?
   response.params
@@ -34,15 +34,15 @@ You can access values in the response hash using symbols or strings.
 If you wanna paginate, just throw the collection into the WillPaginate view helper.
   <%= will_paginate response.docs %>
 
-===The Doc Module
-You can create your own "models" using RSolr::Ext::Doc
+===The "Model" Module
+You can create your own <read-only> "models" using RSolr::Ext::Model
 
   class Book
-    include RSolr::Ext::Doc
+    include RSolr::Ext::Model
     def self.find_by_author(author)
         find(:fq=>'object_type:"book"', :rows=>10, :phrase_filters=>{:author=>author})
     end
   end
   
   all_books = Book.find('*:*')
-  hawk_books = Book.find_by_author('hawk')
+  hawk_books = Book.find_by_author('hawk')

data/lib/rsolr-ext/{findable.rb → connection.rb}

@@ -1,6 +1,5 @@
-# Findable can be mixed into whatever RSolr.connect returns.
 # RSolr::Ext.connect() does this for you.
-# Findable makes querying solr easier by providing a simple #find method.
+# Ext::Connection makes querying solr easier by providing a simple #find method.
 #
 # The #find method behaves differently depending on what you send in.
 #
@@ -24,32 +23,26 @@
 # The following opts are allowed:
 # :include_response - false is default - whether or not to return the whole solr response or just the doc(s)
 # :handler  - nil is default - the request path (/select or /search etc.)
-module RSolr::Ext::Findable
+module RSolr::Ext::Connection
   
   # Examples:
   # find 'jefferson' # q=jefferson - all docs
   # find :first, 'jefferson' # q=jefferson&rows=1 - first doc only
   # find 'jefferson', :phrase_filters=>{:type=>'book'} # q=jefferson&fq=type:"book" - all docs
   # find {:q=>'something'}, :include_response=>true # q=something -- the entire response
-  def find(*args, &blk)
+  def find *args, &blk
     mode, solr_params, opts = extract_find_opts!(*args)
     
     opts[:include_response] ||= true
     
     solr_params[:rows] = 1 if mode == :first
-    valid_solr_params = RSolr::Ext.map_params(solr_params)
+    valid_solr_params = RSolr::Ext::Request.map(solr_params)
     
     response = opts[:handler] ? send_request(opts[:handler], valid_solr_params) : select(valid_solr_params)
     return response if response.is_a?(String)
     
-    response = RSolr::Ext::wrap_response(response)
+    response = RSolr::Ext::Response::Base.new(response)
     
-    if block_given? and response['response']['docs']
-      # yield each doc if a block is given
-      response['response']['docs'].each_with_index do |doc,i|
-        response['response']['docs'][i] = yield(doc)
-      end
-    end
     if opts[:include_response] == true
       response
     else
@@ -85,6 +78,8 @@ module RSolr::Ext::Findable
     end
     # extract solr params
     solr_params = args.shift
+    # if solr_params is NOT a hash like object
+    # force it into a string for the :q param
     unless solr_params.respond_to?(:each_pair)
       solr_params = {:q=>solr_params.to_s}
     end

data/lib/rsolr-ext/doc.rb

@@ -1,97 +1,44 @@
-# include this module into a plain ruby class:
-# class Book
-#   include RSolr::Ext::Doc
-#   connection = RSolr::Ext.connect
-#   default_params = {:phrase_filters=>'type:book'}
-# end
-# 
-# Then:
-# number_10 = Book.find_by_id(10)
-#
 module RSolr::Ext::Doc
   
-  # Class level methods for altering object instances
-  module Callbacks
-    
-    # creates the @hooks container ("hooks" are blocks or procs).
-    # returns an array
-    def hooks
-      @hooks ||= []
-    end
-    
-    # method that only accepts a block
-    # The block is executed when an object is created via #new -> SolrDoc.new
-    # The blocks scope is the instance of the object.
-    def after_initialize(&blk)
-      hooks << blk
-    end
-    
-    # Removes the current set of after_initialize blocks.
-    # You would use this if you wanted to open a class back up,
-    # but clear out the previously defined blocks.
-    def clear_after_initialize_blocks!
-      @hooks = []
-    end
-    
+  # for easy access to the solr id (route helpers etc..)
+  def id
+    self['id']
   end
   
-  #
-  # Findable is a module that gets mixed into the SolrDocument class object.
-  # These methods will be available through the class like: SolrDocument.find and SolrDocument.find_by_id
-  #
-  module Findable
-    
-    attr_accessor :connection
-    
-    def connection
-      @connection ||= RSolr::Ext.connect
+  # Helper method to check if value/multi-values exist for a given key.
+  # The value can be a string, or a RegExp
+  # Multiple "values" can be given; only one needs to match.
+  # 
+  # Example:
+  # doc.has?(:location_facet)
+  # doc.has?(:location_facet, 'Clemons')
+  # doc.has?(:id, 'h009', /^u/i)
+  def has?(k, *values)
+    return if self[k].nil?
+    return true if self.key?(k) and values.empty?
+    target = self[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
-    
-    def find(*args)
-      mode, solr_params, opts = connection.send(:extract_find_opts!, *args)
-      connection.find(*[mode, solr_params, opts]) { |doc| self.new(doc) }
-    end
-    
-    def find_by_id(id, solr_params={}, opts={})
-      connection.find_by_id(id, solr_params, opts) { |doc| self.new(doc) }
-    end
-    
   end
-  
-  # Called by Ruby Module API
-  # extends this *class* object
-  def self.included(base)
-    base.extend Callbacks
-    base.extend Findable
-  end
-  
-  # The original object passed in to the #new method
-  attr :_source_hash
-  
-  # The original object passed, converted to a mash
-  attr :_source_mash
-  
-  # Constructor **for the class that is getting this module included**
-  # source_doc should be a hash or something similar
-  # calls each of after_initialize blocks
-  def initialize(source_doc={})
-    @_source_hash = source_doc
-    @_source_mash = source_doc.to_mash
-    self.class.hooks.each do |h|
-      instance_eval &h
+
+  # helper
+  # key is the name of the field
+  # opts is a hash with the following valid keys:
+  #  - :sep - a string used for joining multivalued field values
+  #  - :default - a value to return when the key doesn't exist
+  # if :sep is nil and the field is a multivalued field, the array is returned
+  def get key, opts={:sep=>', ', :default=>nil}
+    if self.key? key
+      val = self[key]
+      (val.is_a?(Array) and opts[:sep]) ? val.join(opts[:sep]) : val
+    else
+      opts[:default]
     end
   end
-  
-  # for easy access to the solr id (route helpers etc..)
-  def id
-    @_source_mash['id']
-  end
-  
-  # the wrapper method to the @_source_hash object.
-  # If a method is missing, it gets sent to @_source_hash
-  # with all of the original params and block
-  def method_missing(m, *args, &b)
-    @_source_mash.send(m, *args, &b)
-  end
-  
+
 end

data/lib/rsolr-ext/model.rb

@@ -0,0 +1,98 @@
+# include this module into a plain ruby class:
+# class Book
+#   include RSolr::Ext::Model
+#   connection = RSolr::Ext.connect
+#   default_params = {:phrase_filters=>'type:book'}
+# end
+# 
+# Then:
+# number_10 = Book.find_by_id(10)
+#
+module RSolr::Ext::Model
+
+  # Class level methods for altering object instances
+  module Callbacks
+    
+    # method that only accepts a block
+    # The block is executed when an object is created via #new -> SolrDoc.new
+    # The blocks scope is the instance of the object.
+    def after_initialize(&blk)
+      hooks << blk
+    end
+    
+    # Removes the current set of after_initialize blocks.
+    # You would use this if you wanted to open a class back up,
+    # but clear out the previously defined blocks.
+    def clear_after_initialize_blocks!
+      @hooks = []
+    end
+    
+    # creates the @hooks container ("hooks" are blocks or procs).
+    # returns an array
+    def hooks
+      @hooks ||= []
+    end
+    
+  end
+
+  #
+  # Findable is a module that gets mixed into the SolrDocument class object.
+  # These methods will be available through the class like: SolrDocument.find and SolrDocument.find_by_id
+  #
+  module Findable
+  
+    attr_accessor :connection, :default_params
+    
+    def connection
+      @connection ||= RSolr::Ext.connect
+    end
+    
+    # this method decorates the connection find method
+    # and then creates new instance of the class that uses this module.
+    def find(*args)
+      decorate_response_docs connection.find(*args)
+    end
+    
+    # this method decorates the connection find_by_id method
+    # and then creates new instance of the class that uses this module.
+    def find_by_id(id, solr_params={}, opts={})
+      decorate_response_docs connection.find_by_id(id, solr_params, opts)
+    end
+  
+    protected
+  
+    def decorate_response_docs response
+      response['response']['docs'].map!{|d| self.new d }
+      response
+    end
+  
+  end
+
+  # Called by Ruby Module API
+  # extends this *class* object
+  def self.included(base)
+    base.extend Callbacks
+    base.extend Findable
+  end
+
+  # The original object passed in to the #new method
+  attr :_source
+  
+  # Constructor **for the class that is getting this module included**
+  # source_doc should be a hash or something similar
+  # calls each of after_initialize blocks
+  def initialize(source_doc={})
+    @_source = source_doc
+    self.class.hooks.each do |h|
+      instance_eval &h
+    end
+  end
+  
+  # the wrapper method to the @_source object.
+  # If a method is missing, it gets sent to @_source
+  # with all of the original params and block
+  def method_missing(m, *args, &b)
+    @_source.send(m, *args, &b)
+  end
+  
+end

data/lib/rsolr-ext/request.rb

@@ -1,64 +1,101 @@
 module RSolr::Ext::Request
   
-  autoload :Queryable, 'rsolr-ext/request/queryable.rb'
-  
-  class Standard
-    
-    include RSolr::Ext::Mapable
-    include RSolr::Ext::Request::Queryable
-    
-    MAPPED_PARAMS = [
-      :per_page,
-      :page,
-      :queries, # fielded queries
-      :phrases, # quoted q param
-      :filters, # fq params
-      :phrase_filters, # quoted fq params,
-      :facets
-    ]
+  module Params
     
-    def map_per_page(value,output)
-      output[:rows] = value.to_i
-    end
-    
-    def map_page(value,output)
-      raise ':per_page must be set when using :page' unless output[:rows]
-      page = value.to_s.to_i-1
-      page = page < 1 ? 0 : page
-      output[:start] = page * output[:rows]
+    def map input
+      output = {}
+      if input[:per_page]
+        output[:rows] = input.delete :per_page
+      end
+      
+      if page = input.delete(:page)
+        raise ':per_page must be set when using :page' unless output[:rows]
+        page = page.to_s.to_i-1
+        page = page < 1 ? 0 : page
+        output[:start] = page * output[:rows]
+      end
+      
+      if queries = input.delete(:queries)
+        output[:q] = append_to_param output[:q], build_query(queries, false)
+      end
+      if phrases = input.delete(:phrases)
+        output[:q] = append_to_param output[:q], build_query(phrases, true)
+      end
+      if filters = input.delete(:filters)
+        output[:fq] = append_to_param output[:fq], build_query(filters), false
+      end
+      if pfilters = input.delete(:phrase_filters)
+        output[:fq] = append_to_param output[:fq], build_query(pfilters, true), false
+      end
+      if facets = input.delete(:facets)
+        output[:facet] = true
+        output['facet.field'] = append_to_param output['facet.field'], build_query(facets.values), false
+      end
+      output.merge input
     end
     
-    def map_queries(value,output)
-      output[:q] = append_to_param(output[:q], build_query(value, false))
-    end
+  end
+  
+  module QueryHelpers
     
-    def map_phrases(value,output)
-      output[:q] = append_to_param(output[:q], build_query(value, true))
+    # Wraps a string around double quotes
+    def quote(value)
+      %("#{value}")
     end
 
-    def map_filters(value,output)
-      output[:fq] = append_to_param(output[:fq], build_query(value), false)
+    # builds a solr range query from a Range object
+    def build_range(r)
+      "[#{r.min} TO #{r.max}]"
     end
 
-    def map_phrase_filters(value,output)
-      output[:fq] = append_to_param(output[:fq], build_query(value, true), false)
-    end
-    
-    def map_facets(value,output)
-      output[:facet] = true
-      if value[:fields]
-        fields = value[:fields].is_a?(Array) ? value[:fields] : [value[:fields]]
-        fields.each do |f|
-          output['facet.field'] ||= []
-          output['facet.field'] << f
-        end
+    # builds a solr query fragment
+    # if "quote_string" is true, the values will be quoted.
+    # if "value" is a string/symbol, the #to_s method is called
+    # if the "value" is an array, each item in the array is 
+    # send to build_query (recursive)
+    # if the "value" is a Hash, a fielded query is built
+    # where the keys are used as the field names and
+    # the values are either processed as a Range or
+    # passed back into build_query (recursive)
+    def build_query(value, quote_string=false)
+      case value
+      when String,Symbol
+        quote_string ? quote(value.to_s) : value.to_s
+      when Array
+        value.collect do |v|
+          build_query(v, quote_string)
+        end.flatten
+      when Hash
+        return value.collect do |(k,v)|
+          if v.is_a?(Range)
+            "#{k}:#{build_range(v)}"
+          # If the value is an array, we want the same param, multiple times (not a query join)
+          elsif v.is_a?(Array)
+            v.collect do |vv|
+              "#{k}:#{build_query(vv, quote_string)}"
+            end
+          else
+            "#{k}:#{build_query(v, quote_string)}"
+          end
+        end.flatten
       end
     end
+
+    # creates an array where the "existing_value" param is first
+    # and the "new_value" is the last.
+    # All empty/nil items are removed.
+    # the return result is either the result of the
+    # array being joined on a space, or the array itself.
+    # "auto_join" should be true or false.
+    def append_to_param(existing_value, new_value, auto_join=true)
+      values = [existing_value, new_value]
+      values.delete_if{|v|v.nil?}
+      auto_join ? values.join(' ') : values.flatten
+    end
     
   end
   
-  class Dismax < Standard
-    
-  end
+  extend QueryHelpers
+  extend Params
   
 end

data/lib/rsolr-ext/response/docs.rb

@@ -1,45 +1,5 @@
 module RSolr::Ext::Response::Docs
   
-  module Accessible
-    
-    # Helper method to check if value/multi-values exist for a given key.
-    # The value can be a string, or a RegExp
-    # Multiple "values" can be given; only one needs to match.
-    # 
-    # Example:
-    # doc.has?(:location_facet)
-    # doc.has?(:location_facet, 'Clemons')
-    # doc.has?(:id, 'h009', /^u/i)
-    def has?(k, *values)
-      return if self[k].nil?
-      return true if self.key?(k) and values.empty?
-      target = self[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
-
-    # helper
-    # key is the name of the field
-    # opts is a hash with the following valid keys:
-    #  - :sep - a string used for joining multivalued field values
-    #  - :default - a value to return when the key doesn't exist
-    # if :sep is nil and the field is a multivalued field, the array is returned
-    def get(key, opts={:sep=>', ', :default=>nil})
-      if self.key? key
-        val = self[key]
-        (val.is_a?(Array) and opts[:sep]) ? val.join(opts[:sep]) : val
-      else
-        opts[:default]
-      end
-    end
-
-  end
-  
   module Pageable
     
     attr_accessor :start, :per_page, :total
@@ -82,10 +42,8 @@ module RSolr::Ext::Response::Docs
   
   def self.extended(base)
     d = base['response']['docs']
+    d.each{|doc| doc.extend RSolr::Ext::Doc }
     d.extend Pageable
-    d.each do |item|
-      item.extend Accessible
-    end
     d.per_page = base['responseHeader']['params']['rows'].to_s.to_i
     d.start = base['response']['start'].to_s.to_i
     d.total = base['response']['numFound'].to_s.to_i

data/lib/rsolr-ext/response/facets.rb

@@ -1,23 +1,13 @@
 module RSolr::Ext::Response::Facets
   
   # represents a facet value; which is a field value and its hit count
-  class FacetItem
-    attr_reader :value,:hits
-    def initialize(value,hits)
-      @value,@hits=value,hits
-    end
-  end
+  FacetItem = Struct.new :value,:hits
   
   # represents a facet; which is a field and its values
-  class FacetField
-    attr_reader :name
-    attr_accessor :items
-    def initialize(name)
-      @name=name
-      @items=[]
-    end
+  FacetField = Struct.new :name, :items do
+    def items; @items ||= [] end
   end
-
+  
   # @response.facets.each do |facet|
   #   facet.field
   # end

data/lib/rsolr-ext/response.rb

@@ -1,11 +1,19 @@
 module RSolr::Ext::Response
   
-  autoload :Facets, 'rsolr-ext/response/facets'
   autoload :Docs, 'rsolr-ext/response/docs'
+  autoload :Facets, 'rsolr-ext/response/facets'
   autoload :Spelling, 'rsolr-ext/response/spelling'
   
   class Base < Mash
     
+    def initialize *args
+      super *args
+      extend Response if self['response']
+      extend Docs if self['response'] and self['response']['docs']
+      extend Facets if self['facet_counts']
+      extend Spelling if self['spellcheck']
+    end
+    
     def header
       self['responseHeader']
     end
@@ -20,15 +28,7 @@ module RSolr::Ext::Response
     
   end
   
-  # 
-  class Standard < Base
-    
-    def initialize(*args)
-      super(*args)
-      extend Docs
-      extend Facets
-      extend Spelling
-    end
+  module Response
     
     def response
       self[:response]
@@ -41,31 +41,4 @@ module RSolr::Ext::Response
     
   end
   
-  class Dismax < Standard
-    
-  end
-  
-  # 
-  class Luke < Base
-    
-    # Returns an array of fields from the index
-    # An optional rule can be used for "grepping" field names:
-    # field_list(/_facet$/)
-    def field_list(rule=nil)
-      fields.select do |k,v|
-        rule ? k =~ rule : true
-      end.collect{|k,v|k}
-    end
-    
-    def fields
-      self['fields']
-    end
-
-  end# end Luke
-  
-  # Update
-  class Update < Base
-    
-  end
-  
 end

data/lib/rsolr-ext.rb

@@ -4,9 +4,7 @@ lambda { |base|
   $: << base unless $:.include?(base) || $:.include?(File.expand_path(base))
 }.call(File.dirname(__FILE__))
 
-unless defined?(Mash)
-  require 'mash'
-end
+require 'mash' unless defined?(Mash)
 
 unless Hash.respond_to?(:to_mash)
   class Hash
@@ -23,29 +21,19 @@ module RSolr
   
   module Ext
     
-    VERSION = '0.7.35'
+    VERSION = '0.8.0'
     
+    autoload :Connection, 'rsolr-ext/connection.rb'
+    autoload :Doc, 'rsolr-ext/doc.rb'
     autoload :Request, 'rsolr-ext/request.rb'
     autoload :Response, 'rsolr-ext/response.rb'
-    autoload :Mapable, 'rsolr-ext/mapable.rb'
-    autoload :Findable, 'rsolr-ext/findable.rb'
-    autoload :Doc, 'rsolr-ext/doc.rb'
-    
-    # RSolr::Ext.map_params({})
-    def self.map_params(r)
-      RSolr::Ext::Request::Standard.new.map(r)
-    end
-    
-    # RSolr::Ext.wrap_response({})
-    def self.wrap_response(r)
-      RSolr::Ext::Response::Standard.new(r)
-    end
+    autoload :Model, 'rsolr-ext/model.rb'
     
     # c = RSolr::Ext.connect
     # c.find(:q=>'*:*').docs.size
     def self.connect(*args)
       connection = RSolr.connect(*args)
-      connection.extend RSolr::Ext::Findable
+      connection.extend RSolr::Ext::Connection
       connection
     end
     

data/rsolr-ext.gemspec

@@ -1,7 +1,7 @@
 Gem::Specification.new do |s|
 	s.name = "rsolr-ext"
-	s.version = "0.7.35"
-	s.date = "2009-05-28"
+	s.version = "0.8.0"
+	s.date = "2009-07-31"
 	s.summary = "An extension lib for RSolr"
 	s.email = "goodieboy@gmail.com"
 	s.homepage = "http://github.com/mwmitchell/rsolr_ext"
@@ -12,13 +12,12 @@ Gem::Specification.new do |s|
     
     "lib/mash.rb",
     
-    "lib/rsolr-ext/doc.rb",
+    "lib/rsolr-ext/connection.rb",
     
-    "lib/rsolr-ext/findable.rb",
+    "lib/rsolr-ext/doc.rb",
     
-    "lib/rsolr-ext/mapable.rb",
+    "lib/rsolr-ext/model.rb",
     
-    "lib/rsolr-ext/request/queryable.rb",
     "lib/rsolr-ext/request.rb",
     
     "lib/rsolr-ext/response/docs.rb",
@@ -34,7 +33,7 @@ Gem::Specification.new do |s|
     "rsolr-ext.gemspec"
 	]
 	s.test_files = [
-	  'test/findable_test.rb',
+	  'test/connection_test.rb',
 	  'test/request_test.rb',
 	  'test/response_test.rb',
 	  'test/test_unit_test_case.rb',

data/test/{findable_test.rb → connection_test.rb}

@@ -2,7 +2,7 @@ require 'test_unit_test_case'
 require File.join(File.dirname(__FILE__), '..', 'lib', 'rsolr-ext')
 require 'helper'
 
-class RSolrExtFindableTest < Test::Unit::TestCase
+class RSolrExtConnectionTest < Test::Unit::TestCase
   
   test 'RSolr::connect' do
     connection = RSolr::Ext.connect

data/test/request_test.rb

@@ -1,18 +1,26 @@
 require 'test_unit_test_case'
 require File.join(File.dirname(__FILE__), '..', 'lib', 'rsolr-ext')
 
+class Symbol
+  
+  def method_missing n,&b
+    [self, n].join('.').to_sym
+  end
+  
+end
+
 class RSolrExtRequestTest < Test::Unit::TestCase
   
   test 'standard request' do
-    std = RSolr::Ext::Request::Standard.new
-    solr_params = std.map(
+    solr_params = RSolr::Ext::Request.map(
       :page=>2,
       :per_page=>10,
       :phrases=>{:name=>'This is a phrase'},
       :filters=>['test', {:price=>(1..10)}],
       :phrase_filters=>{:manu=>['Apple']},
       :queries=>'ipod',
-      :facets=>{:fields=>['cat', 'blah']}
+      :facets=>{:fields=>['cat', 'blah']},
+      :spellcheck => true
     )
     assert_equal ["test", "price:[1 TO 10]", "manu:\"Apple\""], solr_params[:fq]
     assert_equal 10, solr_params[:start]
@@ -23,8 +31,7 @@ class RSolrExtRequestTest < Test::Unit::TestCase
   end
   
   test 'fq param using the phrase_filters mapping' do
-    std = RSolr::Ext::Request::Standard.new
-    solr_params = std.map(
+    solr_params = RSolr::Ext::Request.map(
       :phrase_filters=>{:manu=>['Apple', 'ASG'], :color=>['red', 'blue']}
     )
     expected = {:fq=>["color:\"red\"", "color:\"blue\"", "manu:\"Apple\"", "manu:\"ASG\""]}

data/test/response_test.rb

@@ -13,7 +13,7 @@ class RSolrExtResponseTest < Test::Unit::TestCase
   
   test 'standard response class' do
     raw_response = eval(mock_query_response)
-    r = RSolr::Ext::Response::Standard.new(raw_response)
+    r = RSolr::Ext::Response::Base.new(raw_response)
     assert r.respond_to?(:response)
     assert r.ok?
     assert_equal 11, r.docs.size
@@ -27,7 +27,7 @@ class RSolrExtResponseTest < Test::Unit::TestCase
   
   test 'standard response doc ext methods' do
     raw_response = eval(mock_query_response)
-    r = RSolr::Ext::Response::Standard.new(raw_response)
+    r = RSolr::Ext::Response::Base.new(raw_response)
     doc = r.docs.first
     assert doc.has?(:cat, /^elec/)
     assert ! doc.has?(:cat, 'elec')
@@ -40,7 +40,7 @@ class RSolrExtResponseTest < Test::Unit::TestCase
   
   test 'Response::Standard facets' do
     raw_response = eval(mock_query_response)
-    r = RSolr::Ext::Response::Standard.new(raw_response)
+    r = RSolr::Ext::Response::Base.new(raw_response)
     assert_equal 2, r.facets.size
     
     field_names = r.facets.collect{|facet|facet.name}
@@ -68,7 +68,7 @@ class RSolrExtResponseTest < Test::Unit::TestCase
   
   test 'response::standard facet_by_field_name' do
     raw_response = eval(mock_query_response)
-    r = RSolr::Ext::Response::Standard.new(raw_response)
+    r = RSolr::Ext::Response::Base.new(raw_response)
     facet = r.facet_by_field_name('cat')
     assert_equal 'cat', facet.name
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: mwmitchell-rsolr-ext
 version: !ruby/object:Gem::Version 
-  version: 0.7.35
+  version: 0.8.0
 platform: ruby
 authors: 
 - Matt Mitchell
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-05-28 00:00:00 -07:00
+date: 2009-07-31 00:00:00 -07:00
 default_executable: 
 dependencies: []
 
@@ -24,10 +24,9 @@ extra_rdoc_files:
 - README.rdoc
 files: 
 - lib/mash.rb
+- lib/rsolr-ext/connection.rb
 - lib/rsolr-ext/doc.rb
-- lib/rsolr-ext/findable.rb
-- lib/rsolr-ext/mapable.rb
-- lib/rsolr-ext/request/queryable.rb
+- lib/rsolr-ext/model.rb
 - lib/rsolr-ext/request.rb
 - lib/rsolr-ext/response/docs.rb
 - lib/rsolr-ext/response/facets.rb
@@ -39,6 +38,7 @@ files:
 - rsolr-ext.gemspec
 has_rdoc: true
 homepage: http://github.com/mwmitchell/rsolr_ext
+licenses: 
 post_install_message: 
 rdoc_options: []
 
@@ -59,12 +59,12 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.2.0
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 2
 summary: An extension lib for RSolr
 test_files: 
-- test/findable_test.rb
+- test/connection_test.rb
 - test/request_test.rb
 - test/response_test.rb
 - test/test_unit_test_case.rb

data/lib/rsolr-ext/mapable.rb

@@ -1,44 +0,0 @@
-# A module that provides method mapping capabilities.
-# The basic idea is to pass in a hash to the #map method,
-# the map method then goes through a list of keys (MAPPED_PARAMS) to
-# be processed. Each key name can match a key in the input hash.
-# If there is a match, a method by the name of "map_#{key}" is
-# called with the following args: input[key], output_hash
-# The method is responsible for processing the value.
-# The return value from the method is not used.
-#
-# For example: if the mapped params list has :query,
-# there should be a method like: map_query(input_value, output_hash)
-# The output_hash is the final hash the the #map method returns,
-# so whatever you do to output_hash gets returned in the end.
-module RSolr::Ext::Mapable
-  
-  # accepts an input hash.
-  # prepares a return hash by copying the input.
-  # runs through all of the keys in MAPPED_PARAMS.
-  # calls any mapper methods that match the current key in MAPPED_PARAMS.
-  # The mapped keys from the input hash are deleted.
-  # returns a new hash.
-  def map(input)
-    result = input.dup
-    self.class::MAPPED_PARAMS.each do |meth|
-      input_value = result.delete(meth)
-      next if input_value.to_s.empty?
-      send("map_#{meth}", input_value, result)
-    end
-    result
-  end
-  
-  # creates an array where the "existing_value" param is first
-  # and the "new_value" is the last.
-  # All empty/nil items are removed.
-  # the return result is either the result of the
-  # array being joined on a space, or the array itself.
-  # "auto_join" should be true or false.
-  def append_to_param(existing_value, new_value, auto_join=true)
-    values = [existing_value, new_value]
-    values.delete_if{|v|v.nil?}
-    auto_join ? values.join(' ') : values.flatten
-  end
-  
-end

data/lib/rsolr-ext/request/queryable.rb

@@ -1,47 +0,0 @@
-# a module to help the creation of solr queries.
-module RSolr::Ext::Request::Queryable
-  
-  # Wraps a string around double quotes
-  def quote(value)
-    %("#{value}")
-  end
-  
-  # builds a solr range query from a Range object
-  def build_range(r)
-    "[#{r.min} TO #{r.max}]"
-  end
-  
-  # builds a solr query fragment
-  # if "quote_string" is true, the values will be quoted.
-  # if "value" is a string/symbol, the #to_s method is called
-  # if the "value" is an array, each item in the array is 
-  # send to build_query (recursive)
-  # if the "value" is a Hash, a fielded query is built
-  # where the keys are used as the field names and
-  # the values are either processed as a Range or
-  # passed back into build_query (recursive)
-  def build_query(value, quote_string=false)
-    case value
-    when String,Symbol
-      quote_string ? quote(value.to_s) : value.to_s
-    when Array
-      value.collect do |v|
-        build_query(v, quote_string)
-      end.flatten
-    when Hash
-      return value.collect do |(k,v)|
-        if v.is_a?(Range)
-          "#{k}:#{build_range(v)}"
-        # If the value is an array, we want the same param, multiple times (not a query join)
-        elsif v.is_a?(Array)
-          v.collect do |vv|
-            "#{k}:#{build_query(vv, quote_string)}"
-          end
-        else
-          "#{k}:#{build_query(v, quote_string)}"
-        end
-      end.flatten
-    end
-  end
-  
-end