blacklight_advanced_search 1.0.0pre1

data/.gitignore

@@ -0,0 +1,5 @@
+.DS_Store
+coverage.data
+coverage/
+log/*
+*.log

data/LICENSE

@@ -0,0 +1,14 @@
+##########################################################################
+# Copyright 2010 Stanford University
+#
+# 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,172 @@
+This is an advanced search plugin for Blacklight ( http://www.projectblacklight.org ).  It is meant to be installed alongside the Blacklight plugin in your application's vendor/plugins directory.
+
+
+== Pre-requisites:
+* The Blacklight plugin ( http://github.com/projectblacklight/blacklight )
+  * NOTE: 2.9 or later is required for current version of Advanced Search plugin. Older tagged versions of Advanced Search may work with older BL. 
+* Parslet gem ( https://github.com/kschiess/parslet )
+
+== Installation:
+Clone the advanced search plugin from github into your application's vendor/plugins directory 
+* cd into your application's vendor/plugins directory and run the following command:
+ git clone http://github.com/projectblacklight/blacklight_advanced_search.git
+
+You can later use standard git commands to update the plugin to a new version.   
+ 
+OR
+
+from your application's main directory, run:
+
+ ./script/plugin install http://github.com/projectblacklight/blacklight_advanced_search.git
+ 
+
+You can later use "./script/plugin update blacklight_advanced_search" to update to latest code.  
+ 
+You will now need to add a parslet gem dependency to your app, since blacklight_advanced_search is not currently a gem itself, you have to do this manually. Add "config.gem 'parslet'" to your config/environment.rb, and then run:
+
+  sudo rake gems:install
+ 
+You can also now *optionally* run the installer script to install some optional example configuration files. In many cases, no configuration is needed for advanced search plugin to work. 
+* cd back to your application's root directory
+ cd ../../
+* And then run the the following command:
+ rake rails:template LOCATION=vendor/plugins/blacklight_advanced_search/template.rb
+
+You may want to set BlacklightAdvancedSearch.config[:advanced_parse_q] = true to enable AND/OR/NOT parsing even in ordinary search, this is not on by default.  
+ 
+== Accessing
+ 
+ 
+The advanced search form will be available in your app at /advanced
+
+  url_for(:controller => "advanced", :action => "index")
+  
+You can also send the advanced search form url parameters representing a search, to have the form add on additional 'advanced' criteria to the search.  For example:
+
+  url_for( params.merge(:controller => "advanced", :action => "index")
+  
+If you do not have the default :controller/:action route enabled for your application, you may need to add a custom route to config/routes.rb.  For example:
+
+    map.advanced 'advanced', :controller => 'advanced', :action => 'index'
+  
+By default there won't be any links in your application to the search form. If you've heavily customized your app, you can put them wherever you want as above. 
+
+However, especially if your app isn't much customized, the optional installer can write a localized Blacklight search form into your application with a 'more options' link to advanced. You may need to adjust your styles to make room for the new link, depending on what you've done with your app. 
+
+
+
+== Configuration:
+
+If your application uses a single Solr qt request handler for all its search fields, then this plugin may work well with no configuration.  Nonetheless, configuration is available to change or improve behavior, or to use a separate Solr request handler for the advanced search plugin.
+
+All plugin configuration mentioned below can be in any initializer in your app (any ruby file in config/initializers), although using the convention config/initializers/blacklight_advanced_search.rb may keep things clear. 
+
+The optional installer script can install a sample blacklight_advanced_search.rb for you which demonstrates various options.
+
+=== Expression parsing in ordinary search
+
+If you turn on this feature with `BlacklightAdvancedSearch.config[:advanced_parse_q] = true`, then the plugin will intercept queries entered in ordinary Blacklight search interface, and parse them for AND/OR/NOT (and parens), producing appropriate Solr query. This allows single-field boolean expressions to be entered in ordinary search, providing a consistent experience with advanced search. 
+
+When this feature is turned on, queries that don't have any special operators (eg: AND, OR, NOT, parens) will still be passed to Solr much the same as they were before. But queries with special operators will have appropriate Solr queries generated for them, usually including nested "_query_" elements, to have the same meaning they would in advanced search. 
+
+Due to limitations of the logic, sometimes these generated Solr queries may not really be as simple as they could be, they may include a *single* nested _query_, which really doens't need to be a nested query at all, although it will still work fine. 
+
+=== Search fields
+
+Your main blacklight search fields are generally defined in config/blacklight_config.rb, under "config[:search_fields]" ( https://github.com/projectblacklight/blacklight/blob/master/config/initializers/blacklight_config.rb#L194 ). If there are particular search fields in your main blacklight config you want excluded from the advanced search form, you can set ":include_in_advanced_search => false"
+
+All advanced search fields must share the same Solr request handler (":qt"). As such, search fields that use a custom ":qt" parameter may not be re-used by the advanced search plugin. However, you may use a separate Solr request handler than the Blacklight default. If you would like the advanced search to use a different Solr request handler than your app's default, set:
+  BlacklightAdvancedSearch.config[:qt]
+to the name of the Solr request handler. 
+
+If you use a separate Solr request handler for advanced search, you must supply a completely separate list of search fields for the advanced search form. Each field is defined by a hash whose format is specified in Blacklight::SearchFields ( https://github.com/projectblacklight/blacklight/blob/master/lib/blacklight/search_fields.rb#L7 ). 
+
+  BlacklightAdvancedSearch.config[:search_fields] = []
+  BlacklightAdvancedSearch.config[:search_fields] << {
+    :key => 'title',
+    :solr_local_parameters => {
+      :qf => "title_t subtitle_t addl_titles_t title_unstem_search^1000" # see ( http://wiki.apache.org/solr/DisMaxQParserPlugin#qf_.28Query_Fields.29 )
+      :pf => "title_t subtitle_t addl_titles_t title_unstem_search^1000" # see ( http://wiki.apache.org/solr/DisMaxQParserPlugin#pf_.28Phrase_Fields.29 )
+    }
+  }
+
+Additionally, to make your advanced search solr requests more concise, you are strongly encouraged to take advantage of the :local_solr_parameters option in your search field definition to use a solr parameter substitution with $variables. 
+
+  BlacklightAdvancedSearch.config[:search_fields] << {
+    :key => 'author'
+    :solr_local_parameters => {
+      :qf=>"$qf_author",
+      :pf=>"$pf_author"
+    }
+  }
+
+Within your solrconfig.xml you may then provide the appropriate custom configuration.
+
+  <requestHandler name="advanced" class="solr.SearchHandler" >
+    <lst name="defaults">
+      <!-- ... -->
+      <str name="qf_author">
+        author_1xx_unstem_search^200
+        author_7xx_unstem_search^50
+        author_8xx_unstem_search^10
+        author_1xx_search^20       vern_author_1xx_search^20
+        author_7xx_search^5        vern_author_7xx_search^5
+        author_8xx_search          vern_author_8xx_search
+      </str>
+      <str name="pf_author">
+        author_1xx_unstem_search^5000
+        author_7xx_unstem_search^3000
+        author_1xx_search^500        vern_author_1xx_search^500
+        author_7xx_search^300        vern_author_7xx_search^300
+        author_8xx_unstem_search^250
+        author_8xx_search^200        vern_author_8xx_search^200
+      </str>
+    </lst>
+  </requestHandler>
+
+
+=== Facets
+
+By default, the advanced search form will show as limits whatever facets are configured as default in your Solr request handler.  To have the advanced search form request specific facets and/or specific facet parameters, you can set config[:form_solr_parameters]. 
+
+  BlacklightAdvancedSearch.config[:form_solr_parameters] = {
+    "facet.field" => ["format", "language_facet"],
+    "facet.limit" => -1, # return all facet values
+    "facet.sort" => "index" # sort by byte order of values
+  }
+ 
+
+=== All Config Options
+
+[config[:qt]] 
+   Solr request handler to use for any search that includes advanced search criteria. Defaults to what the application has set as Blacklight.config[:default_qt]
+[config[:url_key]]
+   Key to use in application URLs to indicate advanced search is included in a query, defaults to "advanced". URLs will have "&search_field=[url key]".
+[config[:search_fields]]
+  Array of search field definitions to be used for advanced search. Each element in the array is a hash of the form required by Blacklight::SearchFields. If left blank, the plugin will use definitions from your main app Blacklight.config[:search_fields] -- only those which have no :qt set, and do not have :include_in_advanced_search => false. 
+[config[:form_solr_paramters]]
+  A hash of solr parameters which will be included in Solr request sent before display of advanced search form. Can be used to set facet parameters for advanced search form display.  
+[config[:advanced_parse_q]]
+  Set to 'true' to have AND/OR/NOT parsed even in ordinary 'simple' blacklight search, and converted to appropriate Solr query for that single field. 
+
+== Translation to Solr Query, technical details
+
+The code for mapping a user-entered query to a Solr query is called "nesting_parsing", and maps to a 'lucene' query parser query, with nested 'dismax' query parser queries. 
+
+Some technical details can be found in the nesting_parsing README: [https://github.com/projectblacklight/blacklight_advanced_search/tree/master/lib/parsing_nesting]
+
+You may also find the rspecs for parsing a user-entered query and converting it to Solr illumnating:
+1. Converting user-entered query to Solr: [https://github.com/projectblacklight/blacklight_advanced_search/blob/master/spec/parsing_nesting/to_solr_spec.rb]
+2. Parsing user-entered query to internal syntax tree: [https://github.com/projectblacklight/blacklight_advanced_search/blob/master/spec/parsing_nesting/build_tree_spec.rb]
+ 
+== Running tests
+
+Test coverage is provided with rspec, run all tests by running:
+   spec ./spec 
+
+  
+== To Do
+
+* Alphabetical sorting of facet values returned by solr in count order (perhaps with limit). 
+
+

data/Rakefile

@@ -0,0 +1,6 @@
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/VERSION

@@ -0,0 +1 @@
+1.0.0pre1

data/app/controllers/advanced_controller.rb

@@ -0,0 +1,61 @@
+# Need to sub-class CatalogController so we get all other plugins behavior
+# for our own "inside a search context" lookup of facets. 
+class AdvancedController < CatalogController
+  include AdvancedHelper # so we get the #advanced_search_context method
+  
+  before_filter :setup_advanced_search_css, :setup_advanced_search_js, :only => :index
+  
+  def index
+    unless request.method==:post
+      @response = get_advanced_search_facets
+    end
+  end
+
+  protected
+  def get_advanced_search_facets
+    
+    search_context_params = {}
+    if (advanced_search_context.length > 0 )
+      # We have a search context, need to fetch facets from within
+      # that context -- but we dont' want to search within any
+      # existing :q or ADVANCED facets, so we remove those params.
+      adv_keys = BlacklightAdvancedSearch.config[:search_fields].collect {|d| d[:key].to_sym}
+      trimmed_params = params.reject do |k,v|        
+        adv_keys.include?(k.to_sym) # the individual q params
+      end
+      trimmed_params.delete(:f_inclusive) # adv facets
+      
+      search_context_params = solr_search_params(trimmed_params)
+      # Don't want to include the 'q' from basic search in our search
+      # context. Kind of hacky becuase solr_search_params insists on
+      # using controller.params, not letting us over-ride. 
+      search_context_params.delete(:q)
+      search_context_params.delete("q")
+      
+      # Also delete any facet-related params, or anything else
+      # we want to set ourselves or inherit from Solr request handler
+      # defaults. 
+      search_context_params.delete_if do |k, v|
+        k = k.to_s
+        (["facet.limit", "facet.sort", "f", "facets", "facet.fields", "qt", "per_page"].include?(k) ||                
+          k =~ /f\..+\.facet\.limit/ ||
+          k =~ /f\..+\.facet\.sort/
+        )        
+      end
+    end
+
+    input = HashWithIndifferentAccess.new
+    input.merge!( search_context_params )
+    input.merge!( :qt => BlacklightAdvancedSearch.config[:qt] , :per_page => 0)
+    input.merge!( BlacklightAdvancedSearch.config[:form_solr_parameters] )
+    
+    
+    Blacklight.solr.find(input.to_hash)
+  end
+  def setup_advanced_search_css
+    stylesheet_links << ["blacklight_advanced_search_styles", {:plugin=>:blacklight_advanced_search}]
+  end
+  def setup_advanced_search_js
+    javascript_includes << ["blacklight_advanced_search_javascript", {:plugin=>:blacklight_advanced_search}]
+  end
+end

data/app/controllers/application_controller.rb

@@ -0,0 +1,5 @@
+class ApplicationController < ActionController::Base
+  helper :all # include all helpers, all the time
+  protect_from_forgery # See ActionController::RequestForgeryProtection for details
+  
+end

data/app/helpers/advanced_helper.rb

@@ -0,0 +1,40 @@
+# Helper methods for the advanced search form
+module AdvancedHelper
+
+  # Fill in default from existing search, if present
+  # -- if you are using same search fields for basic
+  # search and advanced, will even fill in properly if existing
+  # search used basic search on same field present in advanced. 
+  def label_tag_default_for(key)
+    if (! params[key].blank?)
+      return params[key]
+    elsif params["search_field"] == key
+      return params["q"]
+    else
+      return nil
+    end    
+  end
+
+  # Is facet value in adv facet search results?
+  def facet_value_checked?(field, value)
+    params[:f_inclusive] && params[:f_inclusive][field] && params[:f_inclusive][field][value]
+  end
+
+  # Current params without fields that will be over-written by adv. search,
+  # or other fields we don't want. 
+  def advanced_search_context
+    my_params = params.dup
+    [:page, :commit, :f_inclusive, :q, :search_field, :op, :action, :index, :sort, :controller].each do |bad_key|
+      my_params.delete(bad_key)
+    end
+    search_fields_for_advanced_search.each do |field_def|
+      my_params.delete( field_def[:key] )
+    end
+    my_params
+  end
+
+  def search_fields_for_advanced_search
+    BlacklightAdvancedSearch.config[:search_fields] || []
+  end
+  
+end

data/app/views/advanced/_advanced_search_facets.html.erb

@@ -0,0 +1,16 @@
+<% facet_field_names.each do |solr_fname| %>
+<div class="facet_item">
+  <% display_facet = @response.facets.detect {|f| f.name == solr_fname} -%>
+  <% # if it's NOT a refinement facet -- they are handled in get_refine_facet -%>
+  <% if display_facet && display_facet.items.length > 0 %>
+    <h3><%= facet_field_labels[solr_fname] -%> <span class="adv_facet_selections" style="display:none;"></span></h3>
+	<ul>
+      <% display_facet.items.each do |item| -%>
+        <li>
+          <%= check_box_tag "f_inclusive[#{solr_fname}][#{item.value.to_sym}]", 1, facet_value_checked?(solr_fname, item.value)%> <%= label_tag "f_inclusive_#{solr_fname}[#{item.value.to_sym}]", h(item.value) %> (<%= format_num item.hits %>)
+        </li>
+      <% end -%>
+    </ul>
+  <% end %>
+</div>
+<% end %>

data/app/views/advanced/_advanced_search_fields.html.erb

@@ -0,0 +1,6 @@
+<%- BlacklightAdvancedSearch.search_field_list.each do |field_def| -%>
+  <div class="advanced_search_field">
+      <%= label_tag field_def[:key], "#{field_def[:display_label] }:" %>
+      <%= text_field_tag field_def[:key], label_tag_default_for(field_def[:key]) %>
+  </div>
+<%- end -%>

data/app/views/advanced/_advanced_search_form.html.erb

@@ -0,0 +1,48 @@
+<% form_tag catalog_index_path, :class => 'advanced', :method => :get do  %>
+
+  <%= search_as_hidden_fields(:params => advanced_search_context ) %>  
+
+  <div class="input_columns yui-g">
+	      
+    <div class="yui-u first">
+      
+      <div class="query_column column">
+        <h2>Find items that match <%= select_tag(:op, options_for_select({'all'=>'AND','any'=>'OR'}.sort,'all')) %> of the fields below:</h2>
+        
+        <div id="advanced_search">
+          <%= render 'advanced/advanced_search_fields' %>
+        </div>        
+      </div>
+      
+    </div>
+  
+    <div class="yui-u">
+    
+      <div class="limit_column column">      
+        <h2><strong>AND</strong> have these attributes:</h2>
+      
+        <div id="advanced_search_facets" class="limit_input">
+          <%= render 'advanced_search_facets' %>
+        </div>
+      </div>
+    
+    </div>
+    
+  </div>
+  
+  <% unless (search_context_str = render_search_to_s( advanced_search_context)).blank? %>
+    <div class="constraints">
+      <h4>Within search:</h4>
+      <%= search_context_str %>
+    </div>
+  <% end %>
+  
+  
+  <div class="sort_submit_buttons">
+	<%= label_tag(:sort, "Sort results by") %> 
+    <%= select_tag(:sort, options_for_select(Blacklight.config[:sort_fields],'')) %>
+	<%= hidden_field_tag(:search_field, BlacklightAdvancedSearch.config[:url_key]) %>
+    <%= submit_tag 'Search', :class=>'advanced_button', :id=>'advanced_search' %>
+	<%= link_to "Start over", {:controller => "advanced", :action => "index"}, :class =>"reset advanced_button" %>
+  </div>
+<% end %>

data/app/views/advanced/_advanced_search_help.html.erb

@@ -0,0 +1,22 @@
+<div>
+  <h2>Search tips</h2>
+  <ul class="advanced_help">
+   <li>Select "match all" to require all fields.
+   </li>
+
+   <li>Select "match any" to find at least one field.
+   </li>
+
+   <li>Combine keywords and attributes to find specific items.
+   </li>
+
+   <li>Use quotation marks to search as a phrase. 
+   
+   <li>Use "+" before a term to make it required. (Otherwise results matching only some of your terms may be included).</li>
+   
+   <li>Use "-" before a word or phrase to exclude. 
+
+   <li>Use "OR", "AND", and "NOT" to create complex boolean logic. You can use parentheses in your complex expressions. </li>
+   <li>Truncation and wildcards are not supported - word-stemming is done automatically.</li>
+ </ul>
+</div>

data/app/views/advanced/index.html.erb

@@ -0,0 +1,10 @@
+<% @page_title = "More Search Options - #{application_name}" %>
+<script type="text/javascript">
+  $(document).ready(function(){$("form.advanced input:first").focus();});
+</script>
+
+<h1 class="advanced">More Search Options</h1>
+<%= render 'advanced_search_form' %>
+<%- sidebar_items << capture do -%>
+  <%= render "advanced_search_help" %>
+<%- end -%>

data/app/views/blacklight_advanced_search/_facet_limit.html.erb

@@ -0,0 +1,25 @@
+<%-
+# Custom facet_limit partial that displays inclusive 'or' advanced facet
+# limits at the top, then lets you drill down into ordinary facets. 
+#
+# pass in :solr_field local. 
+#
+# Assumes an @advanced_query exists, and probably has #filters for this
+# solr_field. 
+-%>
+
+<h3><%= facet_field_labels[solr_field] -%></h3>
+
+<div class="advanced_facet_limit">
+  <div class="inclusive_or">
+    <h4>Any of:</h4>
+    <ul>
+    <% @advanced_query.filters[solr_field].each do |value| %>
+        <li><span class="selected"><%= h(value) %></span> <%= link_to "[remove]", remove_advanced_facet_param(solr_field, value), :class=>"remove" %></li>
+    <% end %>
+    </ul>
+  </div>
+  
+<%= render(:partial => "catalog/facet_limit", :locals => {:solr_field => solr_field, :display_heading => false}) %>
+
+</div>

data/blacklight_advanced_search.gemspec

@@ -0,0 +1,24 @@
+# -*- coding: utf-8 -*-
+require "lib/blacklight_advanced_search/version"
+
+Gem::Specification.new do |s|
+  s.name = "blacklight_advanced_search"
+  s.version = BlacklightAdvancedSearch::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.authors = ["Jonathan Rochkind", "Chris Beer"]
+  s.email = ["blacklight-development@googlegroups.com"]
+  s.homepage    = "http://projectblacklight.org/"
+  s.summary = "Blacklight Advanced Search plugin"
+
+  s.rubyforge_project = "blacklight"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+
+  s.add_dependency "rails", "~> 3.0"
+  s.add_dependency "blacklight"
+  s.add_dependency "parslet"
+end

data/config/routes.rb

@@ -0,0 +1,3 @@
+Rails.application.routes.draw do
+  match 'advanced' => 'advanced#index'
+end

data/lib/blacklight_advanced_search/advanced_query_parser.rb

@@ -0,0 +1,61 @@
+module BlacklightAdvancedSearch
+  class QueryParser
+    include ParsingNestingParser # only one strategy currently supported. if BlacklightAdvancedSearch.config[:solr_type] == "parsing_nesting"
+    include FilterParser
+    attr_reader :config, :params
+    
+    def initialize(params,config)
+      @params = HashWithIndifferentAccess.new(params)
+      @config = config    
+    end
+
+    def to_solr
+      @to_solr ||= begin
+        {
+          :q => process_query(params,config), 
+          :fq => generate_solr_fq() 
+        }
+      end
+    end
+    
+    # Returns "AND" or "OR", how #keyword_queries will be combined
+    def keyword_op
+      @params["op"] || "AND"
+    end
+    # returns advanced-type keyword queries, see also keyword_op
+    def keyword_queries
+      unless(@keyword_queries)
+        @keyword_queries = {}
+
+        return @keyword_queries unless @params[:search_field] == BlacklightAdvancedSearch.config[:url_key]
+        
+        @config[:search_fields].each do | field_def |
+          key = field_def[:key]
+          if ! @params[ key.to_sym ].blank?
+            @keyword_queries[ key ] = @params[ key.to_sym ]
+          end
+        end
+      end
+      return @keyword_queries
+    end
+    # returns just advanced-type filters
+    def filters
+      unless (@filters)
+        @filters = {}
+        return @filters unless @params[:f_inclusive]
+        @params[:f_inclusive].each_pair do |field, value_hash|
+          value_hash.each_pair do |value, type|
+            @filters[field] ||= []
+            @filters[field] << value
+          end
+        end        
+      end
+      return @filters
+    end
+
+    def empty?
+      filters.empty? && keyword_queries.empty?
+    end
+    
+  end
+end

data/lib/blacklight_advanced_search/catalog_helper_override.rb

@@ -0,0 +1,53 @@
+module BlacklightAdvancedSearch::CatalogHelperOverride
+
+  
+  
+  def remove_advanced_keyword_query(field, my_params = params)
+    my_params = my_params.dup
+    my_params.delete(field)
+    return my_params
+  end
+
+  def remove_advanced_filter_group(field, my_params = params)
+    if (my_params[:f_inclusive])
+      my_params = my_params.dup
+      my_params[:f_inclusive] = my_params[:f_inclusive].dup
+      my_params[:f_inclusive].delete(field)
+    end
+    my_params
+  end
+
+  # Special display for facet limits that include adv search inclusive
+  # or limits.
+  def render_facet_limit(solr_field)
+    unless (@advanced_query && @advanced_query.filters.keys.include?( solr_field))
+      super(solr_field)
+    else
+      # our own display
+      render(:partial => "blacklight_advanced_search/facet_limit", :locals=> {:solr_field => solr_field})
+    end
+  end
+
+  def remove_advanced_facet_param(field, value, my_params = params)
+    my_params = my_params.dup
+    if (my_params[:f_inclusive] && 
+        my_params[:f_inclusive][field] &&
+        my_params[:f_inclusive][field].include?(value))
+        
+      my_params[:f_inclusive] = my_params[:f_inclusive].dup
+      my_params[:f_inclusive][field] = my_params[:f_inclusive][field].dup
+      my_params[:f_inclusive][field].delete(value)
+      
+      my_params[:f_inclusive].delete(field) if my_params[:f_inclusive][field].length == 0
+      
+      my_params.delete(:f_inclusive) if my_params[:f_inclusive].length == 0      
+    end
+
+    my_params.delete_if do |key, value| 
+      [:page, :id, :counter, :commit].include?(key)
+    end
+    
+    my_params
+  end
+  
+end