ansr_blacklight 0.0.3

data/lib/ansr_blacklight/base.rb

@@ -0,0 +1,21 @@
+module Ansr::Blacklight
+  class Base < Ansr::Base
+    include Ansr::Blacklight::Model::Querying
+
+    self.abstract_class = true
+
+    def self.solr_search_params_logic
+    	@solr_search_params_logic || []
+    end
+
+    def self.solr_search_params_logic=(vals)
+      @solr_search_params_logic=vals
+    end
+
+    def self.build_default_scope
+      rel = super
+      solr_search_params_logic.each {|method| rel = self.send(method, rel)}
+      rel
+    end
+  end
+end

data/lib/ansr_blacklight/connection_adapters/no_sql_adapter.rb

@@ -0,0 +1,38 @@
+module Ansr::Blacklight::ConnectionAdapters
+  class NoSqlAdapter < Ansr::ConnectionAdapters::NoSqlAdapter
+
+    def self.connection_for(klass)
+      Ansr::Blacklight.solr
+    end
+
+    def initialize(klass, logger = nil, pool = nil) #:nodoc:
+      super(klass, klass.solr, logger, pool)
+      # the RSolr class has one query method, with the name of the selector the first parm?
+      @method = :send_and_receive
+      @visitor = Ansr::Blacklight::Arel::Visitors::ToNoSql.new(@table)
+    end
+
+    # RSolr
+    def raw_connection
+        @connection
+    end
+
+    def adapter_name
+        'Solr'
+    end
+
+    def to_sql(*args)
+      to_nosql(*args)
+    end
+
+    def execute(query, name='ANSR-SOLR')
+      query = query.dup
+      # TODO: execution context to assign :post to params[:method]
+      params = {params: query, method: :get}
+      params[:data] = params.delete(:params) if params[:method] == :post
+      raw_response = eval(@connection.send(@method, query.path, params))
+      Ansr::Blacklight::Solr::Response.new(raw_response, raw_response['params'])
+    end
+
+  end
+end

data/lib/ansr_blacklight/model/querying.rb

@@ -0,0 +1,29 @@
+module Ansr::Blacklight::Model
+  module Querying
+  extend ActiveSupport::Concern
+
+    module ClassMethods
+
+      def solr
+        Ansr::Blacklight.solr
+      end
+
+      def build_default_scope
+        rel = Ansr::Blacklight::Relation.new(model(), table())
+        rel
+      end
+
+      def unique_key
+        table().unique_key
+      end
+
+      def default_connection_handler
+        @default_connection_handler ||= Ansr::Model::ConnectionHandler.new(Ansr::Blacklight::ConnectionAdapters::NoSqlAdapter)
+      end
+
+      def references
+        []
+      end
+    end
+  end
+end

data/lib/ansr_blacklight/relation.rb

@@ -0,0 +1,50 @@
+module Ansr::Blacklight
+  class Relation < Ansr::Relation
+    include Ansr::Blacklight::SolrProjectionMethods
+  	delegate :blacklight_config, to: :model
+    
+    # some compatibility aliases that should go away to properly genericize
+    alias :facets :filters
+
+    delegate :docs, to: :response
+    delegate :params, to: :response
+
+    # overrides for query response handling
+    def docs_from(response)
+      response.docs
+    end
+
+    def filters_from(response)
+      response.facets
+    end
+
+    def count
+      response.total
+    end
+
+    # overrides for weird Blacklight expectations
+    def max_pages
+      if Kaminari.config.respond_to? :max_pages
+        nil
+      else
+        super
+      end
+    end
+
+    def limit_value
+      (super || default_limit_value) + 1
+    end
+
+    def build_arel
+      arel = super
+      solr_props = {}
+      solr_props[:defType] = defType_value if defType_value
+      solr_props[:wt] = wt_value if wt_value
+      unless solr_props.empty?
+        prop_node = Ansr::Arel::Nodes::ProjectionTraits.new arel.grouping(arel.projections), solr_props
+        arel.projections = [prop_node]
+      end
+      arel
+    end
+  end
+end

data/lib/ansr_blacklight/relation/solr_projection_methods.rb

@@ -0,0 +1,55 @@
+module Ansr::Blacklight
+  module SolrProjectionMethods
+    def defType_value
+      @values[:defType]
+    end
+
+    def defType_value=(value)
+      raise ImmutableRelation if @loaded
+      @values[:defType] = value
+    end
+
+    def defType(value)
+      spawn.defType!(value)
+    end
+
+    def defType!(value)
+      self.defType_value= value
+      self
+    end
+
+    def defType_unscoping
+    end
+
+    def wt_value
+      @values[:wt]
+    end
+
+    def wt_value=(value)
+      raise ImmutableRelation if @loaded
+      @values[:wt] = value
+    end
+
+    def wt(value)
+      spawn.wt!(value)
+    end
+
+    def wt!(value)
+      self.wt_value= (value)
+      self
+    end
+
+    def wt_unscoping
+    end
+
+    # omitHeader
+
+    # timeAllowed
+
+    # debug (true, :timing, :query, :results)
+
+    # explainOther
+
+    # debug.explain.structured
+  end
+end

data/lib/ansr_blacklight/request_builders.rb

@@ -0,0 +1,141 @@
+module Ansr::Blacklight
+  ##
+  # This module contains methods that transform user parameters into parameters that are sent
+  # as a request to Solr when RequestBuilders#solr_search_params is called.
+  #
+  module RequestBuilders
+    extend ActiveSupport::Concern
+
+    def local_field_params(facet_field)
+      cf = table[facet_field]
+      if (cf.is_a? Ansr::Arel::ConfiguredField)
+        return cf.config.fetch(:local, {})
+      else
+        return {}
+      end
+    end
+    # A helper method used for generating solr LocalParams, put quotes
+    # around the term unless it's a bare-word. Escape internal quotes
+    # if needed. 
+    def solr_param_quote(val, options = {})
+      options[:quote] ||= '"'
+      unless val =~ /^[a-zA-Z0-9$_\-\^]+$/
+        val = options[:quote] +
+          # Yes, we need crazy escaping here, to deal with regexp esc too!
+          val.gsub("'", "\\\\\'").gsub('"', "\\\\\"") + 
+          options[:quote]
+      end
+      return val
+    end
+    
+    ##
+    # Take the user-entered query, and put it in the solr params, 
+    # including config's "search field" params for current search field. 
+    # also include setting spellcheck.q. 
+    def add_query_to_solr(field_key, value, opts={})
+      ###
+      # Merge in search field configured values, if present, over-writing general
+      # defaults
+      ###
+      
+      if (::Arel::Nodes::As === field_key)     
+        solr_request[:qt] = field_key.right.to_s
+        field_key = field_key.left
+      end
+
+      search_field = table[field_key]
+      ##
+      # Create Solr 'q' including the user-entered q, prefixed by any
+      # solr LocalParams in config, using solr LocalParams syntax. 
+      # http://wiki.apache.org/solr/LocalParams
+      ##
+      if (Ansr::Arel::ConfiguredField === search_field && !search_field.config.empty?)
+        local_params = search_field.config.fetch(:local,{}).merge(opts).collect do |key, val|
+          key.to_s + "=" + solr_param_quote(val, :quote => "'")
+        end.join(" ")
+        solr_request[:q] = local_params.empty? ? value : "{!#{local_params}}#{value}"
+        search_field.config.fetch(:query,{}).each do |k,v|
+          solr_request[k] = v
+        end
+      else
+        solr_request[:q] = value if value
+      end
+
+      ##
+      # Set Solr spellcheck.q to be original user-entered query, without
+      # our local params, otherwise it'll try and spellcheck the local
+      # params! Unless spellcheck.q has already been set by someone,
+      # respect that.
+      #
+      # TODO: Change calling code to expect this as a symbol instead of
+      # a string, for consistency? :'spellcheck.q' is a symbol. Right now
+      # rspec tests for a string, and can't tell if other code may
+      # insist on a string. 
+      solr_request["spellcheck.q"] = value unless solr_request["spellcheck.q"]
+    end
+
+    ##
+    # Add any existing facet limits, stored in app-level HTTP query
+    # as :f, to solr as appropriate :fq query. 
+    def add_filter_fq_to_solr(solr_request, user_params)   
+
+      # convert a String value into an Array
+      if solr_request[:fq].is_a? String
+        solr_request[:fq] = [solr_request[:fq]]
+      end
+
+      # :fq, map from :f. 
+      if ( user_params[:f])
+        f_request_params = user_params[:f] 
+        
+        f_request_params.each_pair do |facet_field, value_list|
+          opts = local_field_params(facet_field).merge(user_params.fetch(:opts,{}))
+          Array(value_list).each do |value|
+            solr_request.append_filter_query filter_value_to_fq_string(facet_field, value, user_params[:opts])
+          end              
+        end      
+      end
+    end
+    
+    def with_ex_local_param(ex, value)
+      if ex
+        "{!ex=#{ex}}#{value}"
+      else
+        value
+      end
+    end
+
+    private
+
+    ##
+    # Convert a filter/value pair into a solr fq parameter
+    def filter_value_to_fq_string(facet_key, value, facet_opts=nil)
+      facet_field = table[facet_key]
+      facet_config = (Ansr::Arel::ConfiguredField === facet_field)
+      facet_default = (::Arel.star == facet_key)
+      local_params = local_field_params(facet_key)
+      local_params.merge!(facet_opts) if facet_opts
+      local_params = local_params.collect {|k,v| "#{k.to_s}=#{v.to_s}"}
+
+      prefix = ""
+      prefix = "{!#{local_params.join(" ")}}" unless local_params.empty?
+
+      fq = case
+        when facet_default
+          ""
+        when (facet_config and facet_field.date),
+             (value.is_a?(TrueClass) or value.is_a?(FalseClass) or value == 'true' or value == 'false'),
+             (value.is_a?(Integer) or (value.to_i.to_s == value if value.respond_to? :to_i)),
+             (value.is_a?(Float) or (value.to_f.to_s == value if value.respond_to? :to_f))
+             (value.is_a?(DateTime) or value.is_a?(Date) or value.is_a?(Time))
+          "#{prefix}#{facet_field.name}:#{value}"
+        when value.is_a?(Range)
+          "#{prefix}#{facet_field.name}:[#{value.first} TO #{value.last}]"
+        else
+          "{!raw f=#{facet_field.name}#{(" " + local_params.join(" ")) unless local_params.empty?}}#{value}"
+      end
+
+
+    end
+  end
+end

data/lib/ansr_blacklight/solr.rb

@@ -0,0 +1,4 @@
+module Ansr::Blacklight::Solr
+  require 'ansr_blacklight/solr/request'
+  require 'ansr_blacklight/solr/response'
+end

data/lib/ansr_blacklight/solr/request.rb

@@ -0,0 +1,46 @@
+module Ansr::Blacklight::Solr
+  class Request < ::HashWithIndifferentAccess
+    attr_accessor :path
+
+    SINGULAR_KEYS = %W{ facet fl q qt rows start spellcheck spellcheck.q sort 
+    per_page wt hl group defType}
+    ARRAY_KEYS = %W{facet.field facet.query facet.pivot fq hl.fl }
+
+    def initialize(constructor = {})
+      if constructor.is_a?(Hash)
+        super()
+        update(constructor)
+      else
+        super(constructor)
+      end
+      ARRAY_KEYS.each do |key|
+        self[key] ||= []
+      end
+    end
+
+    def append_filter_query(query)
+      self['fq'] << query
+    end
+
+    def append_facet_fields(values)
+      (self['facet.field'] += Array(values)).uniq!
+      self['facet'] = true unless values.blank?
+    end
+
+    def append_facet_query(values)
+      self['facet.query'] += Array(values)
+    end
+
+    def append_facet_pivot(query)
+      self['facet.pivot'] << query
+    end
+
+    def append_highlight_field(query)
+      self['hl.fl'] << query
+    end
+
+    def to_hash
+      reject {|key, value| ARRAY_KEYS.include?(key) && value.blank?}
+    end
+  end
+end

data/lib/ansr_blacklight/solr/response.rb

@@ -0,0 +1,94 @@
+## copied directly from Blacklight::SolrResponse
+class Ansr::Blacklight::Solr::Response < HashWithIndifferentAccess
+
+  require  'ansr_blacklight/solr/response/pagination_methods'
+
+  autoload :Spelling, 'ansr_blacklight/solr/response/spelling'
+  autoload :MoreLikeThis, 'ansr_blacklight/solr/response/more_like_this'
+  autoload :GroupResponse, 'ansr_blacklight/solr/response/group_response'
+  autoload :Group, 'ansr_blacklight/solr/response/group'
+
+  include PaginationMethods
+
+  attr_reader :request_params
+  def initialize(data, request_params)
+    super(data)
+    @request_params = request_params
+    extend Spelling
+    extend Ansr::Facets
+    extend Response
+    extend MoreLikeThis
+  end
+
+  def header
+    self['responseHeader']
+  end
+  
+  def update(other_hash) 
+    other_hash.each_pair { |key, value| self[key] = value } 
+    self 
+  end 
+
+  def params
+      (header and header['params']) ? header['params'] : request_params
+  end
+
+  def rows
+      params[:rows].to_i
+  end
+
+  def docs
+    @docs ||= begin
+      response['docs'] || []
+    end
+  end
+
+  def spelling
+    self['spelling']
+  end
+
+  def grouped(model)
+    @groups ||= self["grouped"].map do |field, group|
+      # grouped responses can either be grouped by:
+      #   - field, where this key is the field name, and there will be a list
+      #        of documents grouped by field value, or:
+      #   - function, where the key is the function, and the documents will be
+      #        further grouped by function value, or:
+      #   - query, where the key is the query, and the matching documents will be
+      #        in the doclist on THIS object
+      if group["groups"] # field or function
+        GroupResponse.new field, model, group, self
+      else # query
+        Group.new({field => field}, model, group, self)
+      end
+    end
+  end
+
+  def group key
+    grouped.select { |x| x.key == key }.first
+  end
+
+  def grouped?
+    self.has_key? "grouped"
+  end
+
+  module Response
+    def response
+      self[:response] || {}
+    end
+    
+    # short cut to response['numFound']
+    def total
+      response[:numFound].to_s.to_i
+    end
+    
+    def start
+      response[:start].to_s.to_i
+    end
+
+    def empty?
+      total == 0
+    end
+    
+  end
+end