mwmitchell-rsolr-ext 0.4.0

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2008-2009 Matt Mitchell
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.rdoc

@@ -0,0 +1,2 @@
+=RSolr::Ext
+A set of helper methods/modules to assist in building Solr queries and handling responses when using the RSolr library.

data/lib/rsolr-ext.rb

@@ -0,0 +1,25 @@
+# add this directory to the load path if it hasn't already been added
+lambda {|base|
+  $: << base unless $:.include?(base) || $:.include?(File.expand_path(base))
+}.call(File.dirname(__FILE__))
+
+unless defined?(Mash)
+  require 'mash'
+end
+
+unless Hash.respond_to?(:to_mash)
+  require 'core_ext'
+end
+
+module RSolr
+  
+  module Ext
+    
+    VERSION = '0.2.1'
+    
+    autoload :Request, 'rsolr-ext/request.rb'
+    autoload :Response, 'rsolr-ext/response.rb'
+    
+  end
+  
+end

data/lib/rsolr-ext/request.rb

@@ -0,0 +1,56 @@
+module RSolr::Ext::Request
+  
+  module Mapable
+    
+    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
+    
+    def append_to_param(existing_value, new_value)
+      values = [existing_value, new_value]
+      values.delete_if{|v|v.nil?}
+      values.join(' ')
+    end
+    
+  end
+  
+  module Queryable
+    
+    def quote(value)
+      %("#{value}")
+    end
+    
+    def build_range(r)
+      "[#{r.min} TO #{r.max}]"
+    end
+    
+    def build_query(value, quote_string=false)
+      case value
+      when String,Symbol
+        return 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)}"
+          else
+            "#{k}:#{build_query(v, quote_string)}"
+          end
+        end.flatten
+      end
+    end
+  end
+  
+  autoload :Standard, 'rsolr-ext/request/standard.rb'
+  autoload :Dismax, 'rsolr-ext/request/dismax.rb'
+  
+end

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

@@ -0,0 +1,3 @@
+class RSolr::Ext::Request::Dismax < RSolr::Ext::Request::Standard
+  
+end

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

@@ -0,0 +1,38 @@
+class RSolr::Ext::Request::Standard
+  
+  include RSolr::Ext::Request::Mapable
+  include RSolr::Ext::Request::Queryable
+  
+  MAPPED_PARAMS = [
+    :per_page,
+    :page,
+    :phrases, # quoted q param
+    :filters, # fq params
+    :phrase_filters # quoted fq 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]
+  end
+  
+  def map_phrases(value,output)
+    output[:q] = append_to_param(output[:q], build_query(value, true))
+  end
+  
+  def map_filters(value,output)
+    output[:fq] = append_to_param(output[:fq], build_query(value))
+  end
+  
+  def map_phrase_filters(value,output)
+    output[:fq] = append_to_param(output[:fq], build_query(value, true))
+  end
+    
+  
+end

data/lib/rsolr-ext/response.rb

@@ -0,0 +1,8 @@
+module RSolr::Ext::Response
+  
+  autoload :Base, 'rsolr-ext/response/base'
+  autoload :Select, 'rsolr-ext/response/select'
+  autoload :Luke, 'rsolr-ext/response/luke'
+  autoload :Update, 'rsolr-ext/response/update'
+  
+end

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

@@ -0,0 +1,35 @@
+#
+# my_solr_hash.extend RSolrExt::Response::Base
+# my_solr_hash.header
+# my_solr_hash.ok?
+#
+module RSolr::Ext::Response::Base
+  
+  def header
+    self[:responseHeader]
+  end
+  
+  def params
+    header[:params]
+  end
+  
+  def status
+    header[:status].to_i
+  end
+  
+  def query_time
+    header[:QTime]
+  end
+  
+  def ok?
+    self.status == 0
+  end
+  
+  # converts to mash, then extends
+  def self.create(hash)
+    mash = hash.is_a?(Mash) ? hash : hash.to_mash
+    mash.extend self
+    mash
+  end
+  
+end # end Base

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

@@ -0,0 +1,53 @@
+module RSolr::Ext::Response::Luke
+  
+  include Base
+  
+  def index
+    self[:index]
+  end
+  
+  def directory
+    index[:directory]
+  end
+  
+  def has_deletions
+    index[:hasDeletions]
+  end
+  
+  def current
+    index[:current]
+  end
+  
+  def max_doc
+    index[:max_doc]
+  end
+  
+  def num_docs
+    index[:numDocs]
+  end
+  
+  def version
+    index[:version]
+  end
+  
+  alias :has_deletions? :has_deletions
+  alias :optimized? :optimized
+  alias :current? :current
+
+  # 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)
+    self[:fields].select do |k,v|
+      rule ? k =~ rule : true
+    end.collect{|k,v|k}
+  end
+  
+  # converts to mash, then extends
+  def self.create(hash)
+    mash = hash.is_a?(Mash) ? hash : hash.to_mash
+    mash.extend self
+    mash
+  end
+  
+end# end Luke

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

@@ -0,0 +1,216 @@
+module RSolr::Ext::Response::Select
+  
+  # module for adding helper methods to each solr response[:docs] object
+  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
+
+  module Facets
+    
+    # represents a facet value; which is a field value and its hit count
+    class FacetValue
+      attr_reader :value,:hits
+      def initialize(value,hits)
+        @value,@hits=value,hits
+      end
+    end
+    
+    # represents a facet; which is a field and its values
+    class Facet
+      attr_reader :field
+      attr_accessor :values
+      def initialize(field)
+        @field=field
+        @values=[]
+      end
+    end
+
+    # @response.facets.each do |facet|
+    #   facet.field
+    # end
+    # "caches" the result in the @facets instance var
+    def facets
+      # memoize!
+      @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_by_field_name ||= {}
+      @facets_by_field_name[name] ||= (
+        facets.detect{|facet|facet.field.to_s == name.to_s}
+      )
+    end
+    
+    def facet_counts
+      @facet_counts ||= self[: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 # end Facets
+  
+  #
+  #
+  #
+  class FacetPaginator
+    
+    attr_reader :total, :items, :previous_offset, :next_offset
+    
+    def initialize(all_facet_values, offset, limit)
+      offset = offset.to_s.to_i
+      limit = limit.to_s.to_i
+      total = all_facet_values.size
+      @items = all_facet_values.slice(0, limit-1)
+      @has_next = total == limit
+      @has_previous = offset > 0
+      @next_offset = offset + (limit-1)
+      @previous_offset = offset - (limit-1)
+    end
+
+    def has_next?
+      @has_next
+    end
+
+    def has_previous?
+      @has_previous
+    end
+
+  end
+  
+  #
+  #
+  #
+  class Paginator
+    
+    attr_reader :start, :per_page, :total
+    
+    def initialize(start, per_page, total)
+      @start = start.to_s.to_i
+      @per_page = per_page.to_s.to_i
+      @total = total.to_s.to_i
+    end
+    
+    # Returns the current page calculated from 'rows' and 'start'
+    # WillPaginate hook
+    def current_page
+      return 1 if start < 1
+      @current_page ||= (start / per_page).ceil + 1
+    end
+
+    # Calcuates the total pages from 'numFound' and 'rows'
+    # WillPaginate hook
+    def total_pages
+      @total_pages ||= per_page > 0 ? (total / 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
+  
+  def paginator
+    @paginator ||= Paginator.new(start, rows, total)
+  end
+  
+  # The main select response class.
+  # Includes the top level Response::Base module
+  # Includes the Pagination module.
+  # Each solr hash doc is extended by the DocExt module.
+  
+  include RSolr::Ext::Response::Base
+  include Facets
+  
+  def response
+    self[:response]
+  end
+  
+  def num_found
+    response[:numFound]
+  end
+  
+  def start
+    response[:start]
+  end
+  
+  def rows
+    params[:rows]
+  end
+  
+  alias :total :num_found
+  alias :offset :start
+  
+  def docs
+    @docs ||= response[:docs].collect{ |d| d=d.to_mash; d.extend(DocExt); d }
+  end
+  
+  # converts to mash, then extends
+  def self.create(hash)
+    mash = hash.is_a?(Mash) ? hash : hash.to_mash
+    mash.extend self
+    mash
+  end
+  
+end # end Select

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

@@ -0,0 +1,13 @@
+# for update responses
+module RSolr::Ext::Response::Update
+  
+  include Base
+  
+  # converts to mash, then extends
+  def self.create(hash)
+    mash = hash.is_a?(Mash) ? hash : hash.to_mash
+    mash.extend self
+    mash
+  end
+  
+end

data/test/test_unit_test_case.rb

@@ -0,0 +1,18 @@
+require 'test/unit'
+
+class Test::Unit::TestCase
+  
+  def self.test(name, &block)
+    test_name = "test_#{name.gsub(/\s+/,'_')}".to_sym
+    defined = instance_method(test_name) rescue false
+    raise "#{test_name} is already defined in #{self}" if defined
+    if block_given?
+      define_method(test_name, &block)
+    else
+      define_method(test_name) do
+        flunk "No implementation provided for #{name}"
+      end
+    end
+  end
+  
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: mwmitchell-rsolr-ext
+version: !ruby/object:Gem::Version 
+  version: 0.4.0
+platform: ruby
+authors: 
+- Matt Mitchell
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-15 00:00:00 -07:00
+default_executable: 
+dependencies: []
+
+description: An extension lib for RSolr
+email: goodieboy@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- lib/rsolr-ext.rb
+- lib/rsolr-ext/params.rb
+- lib/rsolr-ext/request.rb
+- lib/rsolr-ext/request/standard.rb
+- lib/rsolr-ext/request/dismax.rb
+- lib/rsolr-ext/response.rb
+- lib/rsolr-ext/response/base.rb
+- lib/rsolr-ext/response/luke.rb
+- lib/rsolr-ext/response/select.rb
+- lib/rsolr-ext/response/update.rb
+- LICENSE
+- README.rdoc
+- rsolr_ext.gemspec
+has_rdoc: true
+homepage: http://github.com/mwmitchell/rsolr_ext
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: An extension lib for RSolr
+test_files: 
+- test/rsolr_ext_standard_test.rb
+- test/rsolr_ext_test.rb
+- test/test_unit_test_case.rb