blacklight_advanced_search 1.0.0pre1

data/lib/blacklight_advanced_search/controller.rb

@@ -0,0 +1,101 @@
+require 'blacklight_advanced_search/parsing_nesting_parser'
+
+# This module gets included into CatalogController, or another SolrHelper
+# includer, to add behavior into solr_search_params_logic. 
+module BlacklightAdvancedSearch::Controller
+  extend ActiveSupport::Concern
+
+  included do
+    if BlacklightAdvancedSearch.config[:advanced_parse_q]
+      # Only to parse AND/OR in ordinary 'q'
+      solr_search_params_logic << :add_advanced_parse_q_to_solr
+    end
+    
+    # Always, to parse adv search form params. 
+    solr_search_params_logic << :add_advanced_search_to_solr
+    
+
+    helper BlacklightAdvancedSearch::RenderConstraintsOverride
+    helper BlacklightAdvancedSearch::CatalogHelperOverride
+  end
+  
+  
+  # this method should get added into the solr_search_params_logic
+  # list, in a position AFTER normal query handling (:add_query_to_solr),
+  # so it'll overwrite that if and only if it's an advanced search.
+  # adds a 'q' and 'fq's based on advanced search form input. 
+  def add_advanced_search_to_solr(solr_parameters, req_params = params)
+    # If we've got the hint that we're doing an 'advanced' search, then
+    # map that to solr #q, over-riding whatever some other logic may have set, yeah.
+    # the hint right now is :search_field request param is set to a magic
+    # key.     
+    if (req_params[:search_field] == BlacklightAdvancedSearch.config[:url_key] ||
+      req_params[:f_inclusive])
+      # Set this as a controller instance variable, not sure if some views/helpers depend on it. Better to leave it as a local variable
+      # if not, more investigation later.       
+      @advanced_query = BlacklightAdvancedSearch::QueryParser.new(req_params, BlacklightAdvancedSearch.config )
+      deep_merge!(solr_parameters, @advanced_query.to_solr )
+      if @advanced_query.keyword_queries.length > 0
+        # force :qt if set
+        solr_parameters[:qt] = BlacklightAdvancedSearch.config[:qt] if BlacklightAdvancedSearch.config[:qt]
+        solr_parameters[:defType] = "lucene"        
+      end
+      
+    end
+  end
+  
+  # This method can be included in solr_search_params_logic to have us
+  # parse an ordinary entered :q for AND/OR/NOT and produce appropriate
+  # Solr query. Note that it is NOT included in solr_search_params_logic
+  # by default when this module is included, because it is optional behavior.
+  # BlacklightAdvancedSearch init code will add it to CatalogController
+  # if it's configured to do so. You can of course add it yourself
+  # manually too. 
+  def add_advanced_parse_q_to_solr(solr_parameters, req_params = params)
+    unless req_params[:q].blank?
+      field_def = Blacklight.search_field_def_for_key( req_params[:search_field]) ||
+        Blacklight.default_search_field
+      solr_direct_params = field_def[:solr_parameters] || {}
+      solr_local_params = field_def[:solr_local_parameters] || {}
+      
+      deep_merge!(solr_parameters, solr_direct_params)
+      
+      deep_merge!(
+        solr_parameters, 
+        ParsingNesting::Tree.parse(req_params[:q]).to_single_query_params( solr_local_params )  
+       )
+    end
+  end
+
+  
+  protected
+  # Merges new_hash into source_hash, without modifying arguments, but
+  # will merge nested arrays and hashes too. Also will NOT merge nil or blank
+  # from new_hash into old_hash      
+  def deep_merge!(source_hash, new_hash)
+    source_hash.merge!(new_hash) do |key, old, new|
+      if new.respond_to?(:blank) && new.blank?
+        old        
+      elsif (old.kind_of?(Hash) and new.kind_of?(Hash))
+        deep_merge!(old, new)
+      elsif (old.kind_of?(Array) and new.kind_of?(Array))
+        old.concat(new).uniq
+      elsif new.nil?
+        # Allowing nil values to over-write on merge messes things up.
+        # don't set a nil value if you really want to force blank, set
+        # empty string. 
+        old
+      else
+        new
+      end
+    end
+  end
+  
+  
+end
+
+  
+
+
+  
+

data/lib/blacklight_advanced_search/engine.rb

@@ -0,0 +1,47 @@
+require 'blacklight'
+require 'blacklight_advanced_search'
+require 'rails'
+
+module BlacklightAdvancedSearch
+  class Engine < Rails::Engine
+  
+    config.after_initialize do
+      # After local app initializers that may set some config, we
+      # finish it off with defaults and normalization. 
+      BlacklightAdvancedSearch.init
+    end
+
+    
+    # Do these things in a to_prepare block, to try and make them work
+    # in development mode with class-reloading. The trick is we can't
+    # be sure if the controllers we're modifying are being reloaded in
+    # dev mode, if they are in the BL plugin and haven't been copied to
+    # local, they won't be. But we do our best.
+    config.to_prepare do    
+      # Ordinary module over-ride to CatalogController
+      CatalogController.send(:include,  
+          BlacklightAdvancedSearch::Controller  
+      ) unless
+      CatalogController.include?(   
+          BlacklightAdvancedSearch::Controller 
+        )
+      
+      
+      
+      SearchHistoryController.send(:helper,
+        BlacklightAdvancedSearch::RenderConstraintsOverride 
+      ) unless
+        SearchHistoryController.helpers.is_a?( 
+          BlacklightAdvancedSearch::RenderConstraintsOverride 
+        )
+        
+      SavedSearchesController.send(:helper,
+        BlacklightAdvancedSearch::RenderConstraintsOverride 
+      ) unless
+        SearchHistoryController.helpers.is_a?( 
+          BlacklightAdvancedSearch::RenderConstraintsOverride 
+        )
+        
+    end
+  end
+end

data/lib/blacklight_advanced_search/filter_parser.rb

@@ -0,0 +1,13 @@
+module BlacklightAdvancedSearch::FilterParser
+  # Returns an array of solr :fq params. taking advanced search inclusive
+  # facet value lists out of params. 
+  def generate_solr_fq
+      filter_queries = []
+      filters.each do |solr_field, value_list|
+        filter_queries << "#{solr_field}:(" +
+          value_list.collect {|v| '"' + v.gsub('"', '\"') +'"' }.join(" OR  ") +
+          ")"
+      end
+      return filter_queries
+  end
+end

data/lib/blacklight_advanced_search/parsing_nesting_parser.rb

@@ -0,0 +1,18 @@
+require 'parsing_nesting/tree'
+module BlacklightAdvancedSearch::ParsingNestingParser
+  
+  def process_query(params,config)
+    queries = []
+    keyword_queries.each do |field,query| 
+      queries << ParsingNesting::Tree.parse(query).to_query( local_param_hash(field)  )            
+    end
+    queries.join( ' ' + keyword_op + ' ')
+  end
+  
+  def local_param_hash(key)
+    field_def = BlacklightAdvancedSearch.search_field_def_for_key(key)
+
+    (field_def[:solr_parameters] || {}).merge(field_def[:solr_local_parameters] || {})
+  end
+  
+end

data/lib/blacklight_advanced_search/render_constraints_override.rb

@@ -0,0 +1,96 @@
+# Meant to be applied on top of Blacklight view helpers, to over-ride
+# certain methods from RenderConstraintsHelper (newish in BL), 
+# to effect constraints rendering and search history rendering, 
+module BlacklightAdvancedSearch::RenderConstraintsOverride
+
+  #Over-ride of Blacklight method, provide advanced constraints if needed,
+  # otherwise call super. Existence of an @advanced_query instance variable
+  # is our trigger that we're in advanced mode. 
+  def render_constraints_query(my_params = params)
+    if (@advanced_query.nil? || @advanced_query.keyword_queries.empty? )
+      return super(my_params)
+    else
+      content = ""
+      @advanced_query.keyword_queries.each_pair do |field, query|
+        label = BlacklightAdvancedSearch.search_field_def_for_key(field)[:display_label]
+        content << render_constraint_element(
+          label, query,
+          :remove =>
+            catalog_index_path(remove_advanced_keyword_query(field,my_params))
+        )
+      end
+      if (@advanced_query.keyword_op == "OR" &&   
+          @advanced_query.keyword_queries.length > 1)
+        content = '<span class="inclusive_or appliedFilter">' + '<span class="operator">Any of:</span>' + content + '</span>'
+      end
+      
+      return content
+    end
+  end
+
+  #Over-ride of Blacklight method, provide advanced constraints if needed,
+  # otherwise call super. Existence of an @advanced_query instance variable
+  # is our trigger that we're in advanced mode. 
+  def render_constraints_filters(my_params = params)
+    content = super(my_params)
+
+    if (@advanced_query)
+      @advanced_query.filters.each_pair do |field, value_list|
+        label = Blacklight.config[:facet][:labels][field] or field.to_s.capitalize
+        content << render_constraint_element(label, 
+          value_list.join(" OR "),
+          :remove => catalog_index_path( remove_advanced_filter_group(field, my_params) )
+          )
+      end
+    end
+    
+    return content
+  end
+
+  def render_search_to_s_filters(my_params)
+    content = super(my_params)
+    
+    advanced_query = BlacklightAdvancedSearch::QueryParser.new(my_params, BlacklightAdvancedSearch.config )
+    
+    if (advanced_query.filters.length > 0)
+      advanced_query.filters.each_pair do |field, values|
+        label = Blacklight.config[:facet][:labels][field] or field.to_s.capitalize
+      
+        content << render_search_to_s_element( 
+          label,
+          values.join(" OR ")
+        )
+      end      
+    end
+    return content
+  end
+
+  def render_search_to_s_q(my_params)    
+    content = super(my_params)
+
+    advanced_query = BlacklightAdvancedSearch::QueryParser.new(my_params, BlacklightAdvancedSearch.config )
+
+    if (advanced_query.keyword_queries.length > 1 &&
+        advanced_query.keyword_op == "OR")
+        # Need to do something to make the inclusive-or search clear
+
+        display_as = advanced_query.keyword_queries.collect do |field, query|
+          h( BlacklightAdvancedSearch.search_field_def_for_key(field)[:display_label] + ": " + query )
+        end.join(" ; ")
+        
+        content << render_search_to_s_element("Any of",
+          display_as,
+          :escape_value => false
+        )
+    elsif (advanced_query.keyword_queries.length > 0) 
+      advanced_query.keyword_queries.each_pair do |field, query|
+        label = BlacklightAdvancedSearch.search_field_def_for_key(field)[:display_label]
+
+        content << render_search_to_s_element(label, query)
+      end    
+    end
+    
+    return content
+  end
+  
+end

data/lib/blacklight_advanced_search/version.rb

@@ -0,0 +1,10 @@
+module BlacklightAdvancedSearch
+  unless BlacklightAdvancedSearch.const_defined? :VERSION
+    def self.version
+      @version ||= File.read(File.join(File.dirname(__FILE__), '..', '..', 'VERSION')).chomp
+    end
+
+    VERSION = self.version
+  end
+end
+

data/lib/blacklight_advanced_search.rb

@@ -0,0 +1,74 @@
+module BlacklightAdvancedSearch
+  autoload :Controller, 'blacklight_advanced_search/controller'
+  autoload :RenderConstraintsOverride, 'blacklight_advanced_search/render_constraints_override'
+  autoload :CatalogHelperOverride, 'blacklight_advanced_search/catalog_helper_override'
+  autoload :QueryParser, 'blacklight_advanced_search/advanced_query_parser'
+  autoload :ParsingNestingParser, 'blacklight_advanced_search/parsing_nesting_parser'
+  autoload :FilterParser, 'blacklight_advanced_search/filter_parser'
+
+  require 'blacklight_advanced_search/version'
+  require 'blacklight_advanced_search/engine'
+
+  extend Blacklight::SearchFields # for search field config, so we can use same format as BL, or use ones already set in BL even. 
+    
+  # Has to be called in an after_initialize block, to have access
+  # to Blacklight.config already configured, to look at it for defaults. 
+  def self.init
+    # apply defaults to anything not set. 
+    BlacklightAdvancedSearch.config.reverse_merge!( BlacklightAdvancedSearch.config_defaults )
+    
+    logger.info("BlacklightAdvancedSearch.config: initialized with: #{ config.inspect }")
+    Blacklight.config[:search_fields] << {:display_label => 'Advanced', :key => BlacklightAdvancedSearch.config[:url_key], :include_in_simple_select => false, :include_in_advanced_search => false} unless Blacklight.config[:search_fields].map { |x| x[:key] }.include?  BlacklightAdvancedSearch.config[:url_key]
+  end
+
+  def self.logger
+    RAILS_DEFAULT_LOGGER
+  end
+
+  # Hash of our config. The :search_fields key in hash is used by
+  # Blacklight::SearchFields module, must be an array of search field
+  # definitions compatible with that module, or if missing will
+  # inherit Blacklight.config[:search_fields]
+  def self.config
+    @config ||= {}
+  end  
+
+  # Has to be called in an after_initialize, to make sure Blacklight.config
+  # is already defined. 
+  def self.config_defaults
+   config = {}
+   config[:url_key] ||= "advanced"
+   config[:qt] ||= Blacklight.config[:default_qt] ||  
+      (Blacklight.config[:default_solr_params] && Blacklight.config[:default_solr_params][:qt])
+   config[:form_solr_parameters] ||= {}
+
+   
+   config[:search_fields] ||= Blacklight.config[:search_fields].find_all do |field_def|
+     (field_def[:qt].nil? || field_def[:qt] == config[:qt]) &&
+     field_def[:include_in_advanced_search] != false
+   end
+   
+   config
+  end
+  
+
+  def self.solr_local_params_for_search_field(key)
+  
+    field_def = search_field_def_for_key(key)
+
+    solr_params = (field_def[:solr_parameters] || {}).merge(field_def[:solr_local_parameters] || {})
+
+    solr_params.collect do |key, val|
+      key.to_s + "=" + solr_param_quote(val)
+    end.join(" ")
+    
+    end
+
+    def self.solr_param_quote(val)
+      unless val =~ /^[a-zA-Z$_\-\^]+$/
+        val = "'" + val.gsub("'", "\\\'").gsub('"', "\\\"") + "'"
+      end
+      return val
+    end
+
+end

data/lib/generators/blacklight_advanced_search/assets_generator.rb

@@ -0,0 +1,25 @@
+# Copy BlacklightAdvancedSearch assets to public folder in current app. 
+# If you want to do this on application startup, you can
+# add this next line to your one of your environment files --
+# generally you'd only want to do this in 'development', and can
+# add it to environments/development.rb:
+#       require File.join(BlacklightAdvancedSearch.root, "lib", "generators", "blacklight", "assets_generator.rb")
+#       BlacklightAdvancedSearch::AssetsGenerator.start(["--force", "--quiet"])
+
+
+# Need the requires here so we can call the generator from environment.rb
+# as suggested above. 
+require 'rails/generators'
+require 'rails/generators/base'
+module BlacklightAdvancedSearch
+  class AssetsGenerator < Rails::Generators::Base
+    source_root File.expand_path('../templates', __FILE__)
+
+    def assets
+      directory("public/stylesheets")
+      directory("public/javascripts")
+    end
+
+  end
+end
+

data/lib/generators/blacklight_advanced_search/blacklight_advanced_search_generator.rb

@@ -0,0 +1,11 @@
+require 'rails/generators'
+
+class BlacklightAdvancedSearchGenerator < Rails::Generators::Base
+  source_root File.expand_path('../templates', __FILE__)
+
+  require File.expand_path('../assets_generator.rb', __FILE__)
+  def copy_public_assets
+    BlacklightAdvancedSearch::AssetsGenerator.start
+  end
+
+end

data/lib/generators/blacklight_advanced_search/templates/_search_form.html.erb

@@ -0,0 +1,13 @@
+<div id="search" class="search">
+  <% form_tag catalog_index_path, :method => :get do %>
+    <h2 class="search"><%= label_tag(:q, "Search ") %></h2>
+    <%= text_field_tag :q, params[:q], :class => "q" %>
+    <%= label_tag(:search_field, " in ") %>
+    <%= select_tag(:search_field, options_for_select(search_fields, h(params[:search_field])), :title => "Targeted search options", :class=>"search_field") %>
+    
+    <%= search_as_hidden_fields(:omit_keys => [:q, :search_field, :qt, :page]) %>        
+    
+    <%= submit_tag 'search', :class=>'submit' %>
+  <% end %>
+  <%= link_to 'More options', params.merge(:controller=>"advanced", :action=>"index") , :class=>"advanced_search"%> 
+</div>

data/lib/generators/blacklight_advanced_search/templates/blacklight_advanced_search_config.rb

@@ -0,0 +1,86 @@
+## 
+# This example config file is set up to work using the Solr request handler
+# called "advanced" in the example Blacklight solrconfig.xml:
+# http://github.com/projectblacklight/blacklight-jetty/blob/master/solr/conf/solrconfig.xml
+#
+# NOTE WELL: Using a seperate request handler is just one option, in most cases
+# it's simpler to use your default solr request handler set in Blacklight itself,
+# in which case you would not want to set any of the configuration below!
+# See README. 
+
+BlacklightAdvancedSearch.config.merge!(
+  # :search_field => "advanced", # name of key in Blacklight URL, no reason to change usually.
+  
+  # Set advanced_parse_q to true to allow AND/OR/NOT in your basic/simple
+  # Blacklight search, parsed by Advanced Search Plugin. 
+  #:advanced_parse_q => true, 
+  
+  :qt => "advanced" # name of Solr request handler, leave unset to use the same one as your Blacklight.config[:default_qt]
+  
+)
+
+
+  # You don't need to specify search_fields, if you leave :qt unspecified
+  # above, and have search field config in Blacklight already using that
+  # same qt, the plugin will simply use them. But if you'd like to use a
+  # different solr qt request handler, or have another reason for wanting
+  # to manually specify search fields, you can. Uses the hash format
+  # specified in Blacklight::SearchFields
+
+  BlacklightAdvancedSearch.config[:search_fields] = search_fields = []
+  search_fields << {
+    :key =>  'author',
+    :solr_local_parameters => {
+      :pf => "$pf_author",
+      :qf => "$qf_author"
+    }
+  }
+  
+  search_fields << {
+    :key =>  'title',
+    :solr_local_parameters => {
+      :pf => "$pf_title",
+      :qf => "$qf_title"
+    }
+  }
+  
+  search_fields << {
+    :key =>  'subject',
+    :solr_local_parameters => {
+      :pf => "$pf_subject",
+      :qf => "$qf_subject"
+    }
+  }
+
+  search_fields << {
+    :key =>  'keyword',
+    :solr_local_parameters => {
+      :pf => "$pf_keyword",
+      :qf => "$qf_keyword"
+    }
+  }
+
+  search_fields << {
+    :key =>  'numbers',
+    :solr_local_parameters => {
+      :pf => "$pf_number",
+      :qf => "$qf_number"
+    }
+  }
+
+##
+# The advanced search form displays facets as a limit option.
+# By default it will use whatever facets, if any, are returned
+# by the Solr qt request handler in use. However, you can use
+# this config option to have it request other facet params than
+# default in the Solr request handler, in desired.
+
+# BlacklightAdvancedSearch.config[:form_solr_parameters] = {
+  # "facet.field" => [
+    # "format",
+    # "lc_1letter_facet",
+    # "language_facet"    
+  # ],
+  # "facet.limit" => -1,  # all facet values
+  # "facet.sort" => "index"  # sort by index value (alphabetically, more or less)
+# }

data/lib/generators/blacklight_advanced_search/templates/public/javascripts/blacklight_advanced_search_javascript.js

@@ -0,0 +1,62 @@
+$(document).ready(function() {
+  $('.limit_column ul').each(function(){
+    var ul = $(this);
+    // find all ul's that don't have any span descendants with a class of "selected"
+    if($('span.selected', ul).length == 0){
+      // hide it
+      ul.hide();
+      // attach the toggle behavior to the h3 tag
+      $('h3', ul.parent()).click(function(){
+         // toggle the next ul sibling
+         $(this).next('ul').slideToggle();
+      });
+     }
+  });
+  
+  
+  /* Stuff for handling the checkboxes */
+  /* When you click a checkbox, update readout */
+  
+  
+  /* Pass in a jquery obj holding the "selected facet element" spans,  get back
+     a string for display representing currently checked things. */
+  function checkboxesToString(checkbox_elements) {
+    var selectedLabels = new Array();
+    checkbox_elements.each(function() {
+        if ($(this).is(":checked")) {
+          selectedLabels.push( $(this).next('label').text());
+        }
+    });
+    return selectedLabels.join(" OR ");
+  }
+  
+  //Pass in JQuery object of zero or more <div class="facet_item"> blocks,
+  //that contain an h3, some checkboxes, and a span.adv_facet_selections for
+  //display of current selections. Will update the span. 
+  function updateSelectedDisplay(facet_item) {
+    var checkboxes = $(facet_item).find("input:checkbox");
+    var displaySpan = $(facet_item).find("span.adv_facet_selections");
+    var displayStr = checkboxesToString( checkboxes );
+    
+    displaySpan.text( displayStr );
+    if (displayStr == "") {
+      displaySpan.hide();
+    } else {
+      displaySpan.show();
+    }
+    
+    
+  }
+  
+  // on page load, set initial properly
+  $(".facet_item").each(function() {
+      updateSelectedDisplay(this);
+  });
+
+  //change on checkbox change
+  $(".facet_item input:checkbox").change( function() {
+      updateSelectedDisplay( $(this).closest(".facet_item"));
+  });
+  
+  
+});

data/lib/generators/blacklight_advanced_search/templates/public/stylesheets/advanced_results.css

@@ -0,0 +1,41 @@
+/* Classes used for styling our custom components on the search results page */
+
+/* constraints */
+
+.inclusive_or .operator {
+  margin-right: 1em;
+}
+
+.inclusive_or .appliedFilter {
+  background-color: #F0F0F0; 
+}
+
+/* making it match an h3 */
+#appliedParams .inclusive_or .operator {
+  font-weight: bold;  
+  color: #555555;
+  font-size: 108%;
+}
+
+/*  Facet limit */
+
+  /* over-ride BL */
+#facets .advanced_facet_limit ul {
+  border-bottom: none;
+  padding-bottom: 0;
+}
+
+
+.facet_limit .inclusive_or h4 {
+  margin-bottom: 0.5em;
+}
+
+.facet_limit .inclusive_or li {
+  margin-left: 1em;
+}
+
+/* optional link to search form */
+.search .advanced_search {
+  font-size: 83.33%; 
+}
+