gsolr_ext 0.12.3

data/lib/gsolr_ext.rb

@@ -0,0 +1,42 @@
+# add this directory to the load path if it hasn't already been added
+
+$:.unshift(File.dirname(__FILE__)) unless
+  $:.include?(File.dirname(__FILE__)) || $:.include?(File.expand_path(File.dirname(__FILE__)))
+
+require File.join(File.dirname(__FILE__), 'mash') unless defined?(Mash)
+
+unless Hash.respond_to?(:to_mash)
+  class Hash
+    def to_mash
+      Mash.new(self)
+    end
+  end
+end
+
+require 'gsolr'
+require 'gsolr_ext'
+
+module GSolr
+  module Ext
+    autoload :Client, 'gsolr_ext/client.rb'
+    autoload :Doc, 'gsolr_ext/doc.rb'
+    autoload :Request, 'gsolr_ext/request.rb'
+    autoload :Response, 'gsolr_ext/response.rb'
+    autoload :Model, 'gsolr_ext/model.rb'
+
+    def self.version
+      @version ||= File.read(File.join(File.dirname(__FILE__), '..', 'VERSION'))
+    end
+
+    # modify the GSolr::Client (provides #find and #luke methods)
+    GSolr::Client.class_eval do
+      include GSolr::Ext::Client
+    end
+
+    # this is for backward compatibility: GSolr::Ext.connect
+    # recommended way is to just use GSolr.connect
+    def self.connect(*args, &blk)
+      GSolr.connect(*args, &blk)
+    end
+  end
+end

data/lib/gsolr_ext/client.rb

@@ -0,0 +1,65 @@
+module GSolr
+  module Ext
+    module Client
+      # TWO modes of arguments:
+      #
+      # <request-handler-path>, <solr-params-hash>
+      # OR
+      # <solr-params-hash>
+      #
+      # The default request-handler-path is /select
+      # 
+      # If a hash is used for solr params, all of the normal GSolr::Ext::Request
+      # mappings are available (everything else gets passed to solr).
+      # Returns a new GSolr::Ext::Response::Base object.
+      def find *args
+        # remove the handler arg - the first, if it is a string OR set default
+        path = args.first.is_a?(String) ? args.shift : '/select'
+        # remove the params - the first, if it is a Hash OR set default
+        params = args.first.kind_of?(Hash) ? args.shift : {}
+        # send path, map params and send the rest of the args along
+        response = self.request path, GSolr::Ext::Request.map(params), *args
+        GSolr::Ext::Response::Base.new(response, path, params)
+      end
+  
+      # TWO modes of arguments:
+      #
+      # <request-handler-path>, <solr-params-hash>
+      # OR
+      # <solr-params-hash>
+      #
+      # The default request-handler-path is /admin/luke
+      # The default params are numTerms=0
+      #
+      # Returns a new Mash object.
+      def luke *args
+        path = args.first.is_a?(String) ? args.shift : '/admin/luke'
+        params = args.pop || {}
+        params['numTerms'] ||= 0
+        self.request(path, params).to_mash
+      end
+  
+      # sends request to /admin/ping
+      def ping *args
+        path = args.first.is_a?(String) ? args.shift : '/admin/ping'
+        params = args.pop || {}
+        self.request(path, params).to_mash
+      end
+  
+      # Ping the server and make sure it is alright
+      #   solr.ping?
+      #
+      # It returns true if the server pings and the status is OK
+      # It returns false otherwise -- which probably cannot happen
+      # Or raises an exception if there is a failure to connect or
+      # the ping service is not activated in the solr server
+      #
+      # The default configuration point of the PingRequestHandler
+      # in the solr server of '/admin/ping' is assumed.
+      #
+      def ping?
+        ping['status'] == 'OK'
+      end
+    end
+  end
+end

data/lib/gsolr_ext/doc.rb

@@ -0,0 +1,44 @@
+module GSolr::Ext::Doc
+  
+  # for easy access to the solr id (route helpers etc..)
+  def id
+    self['id']
+  end
+  
+  # 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

data/lib/gsolr_ext/model.rb

@@ -0,0 +1,111 @@
+# include this module into a plain ruby class:
+# class Book
+#   include GSolr::Ext::Model
+#   connection = GSolr::Ext.connect
+#   default_params = {:phrase_filters=>'type:book'}
+# end
+# 
+# Then:
+# number_10 = Book.find_by_id(10)
+#
+module GSolr::Ext::Model
+  
+  # ripped from MongoMapper!
+  module Pluggable
+    
+    def plugins
+      @plugins ||= []
+    end
+    
+    def plugin(mod)
+      extend mod::ClassMethods     if mod.const_defined?(:ClassMethods)
+      include mod::InstanceMethods if mod.const_defined?(:InstanceMethods)
+      mod.configure(self)          if mod.respond_to?(:configure)
+      plugins << mod
+    end
+    
+  end
+  
+  # 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: SolrDocument.find
+  #
+  module Findable
+    
+    attr_accessor :connection
+    
+    def connection
+      @connection ||= GSolr::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, &block
+      response = connection.find(*args)
+      response.docs.map {|doc|
+        d = self.new doc, response
+        yield d if block_given?
+        d
+      }
+    end
+    
+  end
+  
+  # Called by Ruby Module API
+  # extends this *class* object
+  def self.included(base)
+    base.extend Pluggable
+    base.extend Callbacks
+    base.extend Findable
+    base.send :include, GSolr::Ext::Doc
+  end
+  
+  attr_reader :solr_response
+  
+  # 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={}, solr_response=nil)
+    @_source = source_doc.to_mash
+    @solr_response = solr_response
+    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/gsolr_ext/request.rb

@@ -0,0 +1,110 @@
+module GSolr::Ext::Request
+  
+  module Params
+    
+    def map input_params
+      input = input_params.dup
+      
+      output = {}
+      
+      if input[:per_page]
+        output[:rows] = input.delete(:per_page).to_i
+      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
+      
+      # remove the input :q params
+      output[:q] = input.delete :q
+      output[:fq] = input.delete(:fq) if input[:fq]
+      
+      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 phrase_filters = input.delete(:phrase_filters)
+        output[:fq] = append_to_param output[:fq], build_query(phrase_filters, 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
+    
+  end
+  
+  module QueryHelpers
+    
+    # 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,Numeric
+        quote_string ? quote(value.to_s) : value.to_s
+      when Array
+        value.collect do |v|
+          build_query(v, quote_string)
+        end.flatten
+      when Range
+        build_range(value)
+      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
+  
+  extend QueryHelpers
+  extend Params
+  
+end

data/lib/gsolr_ext/response.rb

@@ -0,0 +1,65 @@
+module GSolr::Ext::Response
+  
+  autoload :Docs, 'gsolr_ext/response/docs'
+  autoload :Facets, 'gsolr_ext/response/facets'
+  autoload :Spelling, 'gsolr_ext/response/spelling'
+  
+  class Base < Mash
+    
+    attr :original_hash
+    attr_reader :request_path, :request_params
+    
+    def initialize hash, handler, request_params
+      super hash
+      @original_hash = hash
+      @request_path, @request_params = request_path, request_params
+      extend Response
+      extend Docs
+      extend Facets
+      extend Spelling
+    end
+    
+    def header
+      self['responseHeader']
+    end
+    
+    def rows
+      params[:rows].to_i
+    end
+    
+    def params
+      (header and header['params']) ? header['params'] : request_params
+    end
+    
+    def ok?
+      (header and header['status']) ? header['status'] == 0 : nil
+    end
+    
+    def method_missing *args, &blk
+      self.original_hash.send *args, &blk
+    end
+    
+  end
+  
+  module Response
+    
+    def response
+      self[:response]
+    end
+    
+    # short cut to response['numFound']
+    def total
+      response[:numFound].to_s.to_i
+    end
+    
+    def total
+      response[:numFound].to_s.to_i
+    end
+    
+    def start
+      response[:start].to_s.to_i
+    end
+    
+  end
+  
+end

data/lib/gsolr_ext/response/docs.rb

@@ -0,0 +1,56 @@
+module GSolr::Ext::Response::Docs
+  
+  module Pageable
+    
+    attr_accessor :start, :per_page, :total
+    
+    # Returns the current page calculated from 'rows' and 'start'
+    # WillPaginate hook
+    def current_page
+      return 1 if start < 1
+      per_page_normalized = per_page < 1 ? 1 : per_page
+      @current_page ||= (start / per_page_normalized).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) ? total_pages : current_page+1
+    end
+    
+    def has_next?
+      current_page < total_pages
+    end
+    
+    def has_previous?
+      current_page > 1
+    end
+    
+  end
+  
+  def self.extended(base)
+    d = base['response']['docs']
+    d.each{|doc| doc.extend GSolr::Ext::Doc }
+    d.extend Pageable
+    d.per_page = base.rows
+    d.start = base.start
+    d.total = base.total
+  end
+  
+  def docs
+    response['docs']
+  end
+  
+end