mwmitchell-rsolr 0.7.1 → 0.8.0

data/lib/rsolr/connection/base.rb

@@ -1,101 +0,0 @@
-#
-# Connection adapter decorator
-#
-class RSolr::Connection::Base
-  
-  attr_reader :adapter, :opts
-  
-  # "adapter" is instance of:
-  #   RSolr::Adapter::HTTP
-  #   RSolr::Adapter::Direct (jRuby only)
-  def initialize(adapter, opts={})
-    @adapter = adapter
-    @opts = opts
-  end
-  
-  # send request (no param mapping) 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 RSolr::Response::Query is returned
-  #   NOTE: to get raw ruby, use :wt=>'ruby'
-  # There is NO param mapping here, what you put it is what gets sent to Solr
-  def query(*args)
-    params = map_params(args.extract_options!)
-    args << params
-    response = @adapter.query(*args)
-    params[:wt] == :ruby ? RSolr::Response::Query::Base.new(response) : response
-  end
-  
-  # Finds a document by its id
-  def find_by_id(*args)
-    params = map_params(args.extract_options!)
-    params[:q] = 'id:"#{id}"'
-    args << params
-    self.query(*args)
-  end
-  
-  # 
-  def update(*args)
-    params = map_params(args.extract_options!)
-    args << params
-    response = @adapter.update(*args)
-    params[:wt] == :ruby ? RSolr::Response::Update.new(response) : response
-  end
-  
-  def index_info(*args)
-    params = map_params(args.extract_options!)
-    args << params
-    response = @adapter.index_info(*args)
-    params[:wt] == :ruby ? RSolr::Response::IndexInfo.new(response) : response
-  end
-  
-  def add(*args, &block)
-    update message.add(*args, &block)
-  end
-  
-  # send </commit>
-  def commit(*args)
-    update message.commit, *args
-  end
-  
-  # send </optimize>
-  def optimize(*args)
-    update message.optimize, *args
-  end
-  
-  # send </rollback>
-  # NOTE: solr 1.4 only
-  def rollback(*args)
-    update message.rollback, *args
-  end
-  
-  # Delete one or many documents by id
-  #   solr.delete_by_id 10
-  #   solr.delete_by_id([12, 41, 199])
-  def delete_by_id(*args)
-    update message.delete_by_id(args.shift), *args
-  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(*args)
-    update message.delete_by_query(args.shift), *args
-  end
-  
-  protected
-  
-  # shortcut to solr::message
-  def message
-    RSolr::Message
-  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)
-    params||={}
-    {:wt=>:ruby}.merge(params)
-  end
-  
-end

data/lib/rsolr/query.rb

@@ -1,58 +0,0 @@
-module RSolr::Query
-  
-  module HelperMethods
-    
-    # returns a quoted or non-quoted string
-    # "value" should be a string
-    # "quote" should be true/false
-    def prep_value(value, quote)
-      quote ? %("#{value}") : value
-    end
-    
-    # value can be a string, array, hash or symbol
-    # symbols are treated as strings
-    # arrays are recursed through #build_query
-    # keys for hashes are fields for fielded queries, the values are recused through #build_query
-    # strings/symbols are sent to #prep_value for possible quoting
-    #
-    # opts can have:
-    #   :quote=>bool - default false
-    #   :join=>string - default ' '
-    def build_query(value, opts={})
-      opts[:join]||=' '
-      opts[:quote]||=false
-      result = (
-        case value
-        when Array
-          value.collect do |item|
-            build_query item, opts
-          end.flatten
-        when String,Symbol
-          [prep_value(value.to_s, opts[:quote])]
-        when Hash
-          value.collect do |(k,v)|
-            "#{k}:#{build_query(v, opts)}"
-          end.flatten
-        else
-          [prep_value(value.to_s, opts[:quote])]
-        end
-      )
-      opts[:join] ? result.join(opts[:join]) : result
-    end
-  
-    # start_for(2, 10)
-    # calculates the :start value for pagination etc..
-    def start_for(current_page, per_page)
-      page = current_page.to_s.to_i
-      page = page > 0 ? page : 1
-      ((page - 1) * (per_page || 0))
-    end
-  
-  end # end HelperMethods
-  
-  # Easy access: RSolr::Query::Helper.start_for(page=1, per_page=10)
-  class Helper
-    extend HelperMethods
-  end
-  
-end

data/lib/rsolr/response.rb

@@ -1,8 +0,0 @@
-module RSolr::Response
-  
-  autoload :Base, 'rsolr/response/base'
-  autoload :Query, 'rsolr/response/query'
-  autoload :IndexInfo, 'rsolr/response/index_info'
-  autoload :Update, 'rsolr/response/update'
-  
-end

data/lib/rsolr/response/base.rb

@@ -1,25 +0,0 @@
-# default/base response object
-# This is where the ruby "eval" happens
-# So far, all response classes extend this
-class RSolr::Response::Base
-  
-  # the object that contains the original :body, :params, full solr :query, post :data etc.
-  attr_reader :input
-  
-  attr_reader :data, :header, :params, :status, :query_time
-  
-  def initialize(input)
-    input = {:body=>input} if input.is_a?(String)
-    @input = input
-    @data = Kernel.eval(input[:body]).to_mash
-    @header = @data[:responseHeader]
-    @params = @header[:params]
-    @status = @header[:status]
-    @query_time = @header[:QTime]
-  end
-  
-  def ok?
-    self.status == 0
-  end
-  
-end

data/lib/rsolr/response/index_info.rb

@@ -1,33 +0,0 @@
-# response for /admin/luke
-class RSolr::Response::IndexInfo < RSolr::Response::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]
-    # index fields
-    @has_deletions = @index[:hasDeletions]
-    @optimized = @index[:optimized]
-    @current = @index[:current]
-    @max_doc = @index[:maxDoc]
-    @num_docs = @index[:numDocs]
-    @version = @index[:version]
-  end
-  
-  # 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)
-    @data[:fields].select do |k,v|
-      rule ? k =~ rule : true
-    end.collect{|k,v|k}
-  end
-  
-  
-end

data/lib/rsolr/response/query.rb

@@ -1,163 +0,0 @@
-# response module for queries
-module RSolr::Response::Query
-  
-  # module for adding helper methods to each Hash document
-  module DocExt
-    
-    # Helper method to check if value/multi-values exist for a given key.
-    # The value can be a string, or a RegExp
-    # 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
-  
-  # from the delsolr project -> http://github.com/avvo/delsolr/tree/master/lib/delsolr/response.rb
-  module Facets
-    
-    class FacetValue
-      attr_reader :value,:hits
-      def initialize(value,hits)
-        @value,@hits=value,hits
-      end
-    end
-    
-    class Facet
-      attr_reader :field
-      attr_accessor :values
-      def initialize(field)
-        @field=field
-        @values=[]
-      end
-    end
-    
-    # @response.facet_fields.each do |facet|
-    #   facet.field
-    # end
-    # "caches" the result in the @facets instance var
-    def facets
-      @facets ||= (
-        facet_fields.inject([]) do |acc,(facet_field_name,values_and_hits_list)|
-          acc << facet = Facet.new(facet_field_name)
-          # the values_and_hits_list is an array where a value is immediately followed by it's hit count
-          # so we shift off an item (the value)
-          while value = values_and_hits_list.shift
-            # and then shift off the next to get the hit value
-            facet.values << FacetValue.new(value, values_and_hits_list.shift)
-            # repeat until there are no more pairs in the values_and_hits_list array
-          end
-          acc
-        end
-      )
-    end
-    
-    # pass in a facet field name and get back a Facet instance
-    def facet_by_field_name(name)
-      facets.detect{|facet|facet.field.to_s == name.to_s}
-    end
-    
-    def facet_counts
-      @facets ||= data['facet_counts'] || {}
-    end
-    
-    # Returns the hash of all the facet_fields (ie: {'instock_b' => ['true', 123, 'false', 20]}
-    def facet_fields
-      @facet_fields ||= facet_counts['facet_fields'] || {}
-    end
-    
-    # Returns all of the facet queries
-    def facet_queries
-      @facet_queries ||= facet_counts['facet_queries'] || {}
-    end
-    
-  end
-  
-  #
-  #
-  #
-  module Pagination
-    
-    # alias to the Solr param, 'rows'
-    def per_page
-      @per_page ||= params['rows'].to_s.to_i
-    end
-    
-    # Returns the current page calculated from 'rows' and 'start'
-    # WillPaginate hook
-    def current_page
-      @current_page ||= (self.start / self.per_page).ceil + 1
-    end
-    
-    # Calcuates the total pages from 'numFound' and 'rows'
-    # WillPaginate hook
-    def total_pages
-      @total_pages ||= self.per_page > 0 ? (self.total / self.per_page.to_f).ceil : 1
-    end
-    
-    # returns the previous page number or 1
-    # WillPaginate hook
-    def previous_page
-      @previous_page ||= (current_page > 1) ? current_page - 1 : 1
-    end
-    
-    # returns the next page number or the last
-    # WillPaginate hook
-    def next_page
-      @next_page ||= (current_page < total_pages) ? current_page + 1 : total_pages
-    end
-    
-  end
-  
-  # The base query response class
-  # adds to the Solr::Response::Base class by defining a few more attributes,
-  # includes the Pagination module, and extends each of the doc hashes
-  # with Solr::Response::Query::DocExt
-  class Base < RSolr::Response::Base
-    
-    include RSolr::Response::Query::Pagination
-    include RSolr::Response::Query::Facets
-    
-    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].collect{ |d| d=d.to_mash; d.extend(DocExt); d }
-      @num_found = @response[:numFound]
-      @start = @response[:start]
-    end
-  
-  end
-  
-end

data/lib/rsolr/response/update.rb

@@ -1,4 +0,0 @@
-# response class for update requests - not sure if this is needed yet?
-class RSolr::Response::Update < RSolr::Response::Base
-  
-end

data/test/query_helper_test.rb

@@ -1,30 +0,0 @@
-require File.join(File.dirname(__FILE__), 'test_helpers.rb')
-
-class RSolrQueryHelperTest < RSolrBaseTest
-  
-  H = RSolr::Query::Helper
-  
-  test 'pre_value' do
-    value = 'the man'
-    assert_equal 'the man', H.prep_value(value, false)
-    assert_equal "\"the man\"", H.prep_value(value, :quote=>true)
-  end
-  
-  test 'build_query' do
-    assert_equal 'testing', H.build_query('testing')
-    assert_equal '"testing"', H.build_query('testing', :quote=>true)
-    assert_equal 'testing again', H.build_query(['testing', 'again'])
-    assert_equal '"testing" "again"', H.build_query(['testing', 'again'], :quote=>true)
-    assert_equal 'name:whatever', H.build_query({:name=>'whatever'})
-    assert_equal 'name:"whatever"', H.build_query({:name=>'whatever'}, :quote=>true)
-    assert_equal 'sam name:whatever i am', H.build_query(['sam', {:name=>'whatever'}, 'i', 'am'])
-    assert_equal 'testing AND blah', H.build_query(['testing', 'blah'], :join=>' AND ')
-  end
-  
-  test 'start_for' do
-    per_page = 8
-    current_page = 2
-    assert_equal 8, H.start_for(current_page, per_page)
-  end
-  
-end

data/test/response/base_test.rb

@@ -1,38 +0,0 @@
-require File.join(File.dirname(__FILE__), '..', 'test_helpers')
-
-class ResponseBaseTest < RSolrBaseTest
-  
-  def test_accessors
-    
-    adapter_response = {:body=>mock_query_response}
-    
-    r = RSolr::Response::Base.new(adapter_response)
-    
-    assert_class Mash, r.data
-    assert_class Mash, r.params
-    assert_class Mash, r.header
-    
-    # make sure the incoming adapter response is the same as the response.input
-    assert_equal adapter_response, r.input
-    
-    assert_equal r.query_time, r.header[:QTime]
-    assert_equal r.query_time, r.header['QTime']
-    
-    assert_equal r.params, r.header[:params]
-    assert_equal r.params, r.header['params']
-    
-    assert_equal '*:*', r.params[:q]
-    assert_equal '*:*', r.params['q']
-    
-    assert_equal 0, r.status
-    assert_equal r.status, r.header[:status]
-    assert_equal r.status, r.header['status']
-    
-    assert_equal r.header, r.data[:responseHeader]
-    assert_equal r.header, r.data['responseHeader']
-    
-    assert r.ok?
-    
-  end
-  
-end