blacklight_advanced_search 1.0.0pre1

data/spec/parsing_nesting/build_tree_spec.rb

@@ -0,0 +1,238 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+require 'parsing_nesting/grammar'
+require 'parsing_nesting/tree'
+
+
+module ParseTreeSpecHelper
+  include ParsingNesting::Tree
+  
+  def parse(s)
+    ParsingNesting::Tree.parse(s)
+  end
+  
+  # for things expected to be a one-element list, 
+  # make sure they are and return the element
+  def parse_one_element(s)
+    l = parse(s)
+    l.should be_kind_of( List )
+    l.list.length.should == 1
+    return l.list.first
+  end
+  
+  def should_be_and_list(graph)
+    graph.should be_kind_of( AndList )
+    yield graph.list if block_given?
+  end
+  
+  def should_be_list(graph)
+    graph.should be_kind_of( List)
+    yield graph.list if block_given?
+  end
+  
+  def should_be_or_list(graph)
+    graph.should be_kind_of( OrList )
+    yield graph.list if block_given?
+  end
+  
+  def should_be_term(graph, value)
+    graph.should be_kind_of( Term )
+    graph.value.should == value
+  end
+  
+  def should_be_phrase(graph, value)
+    graph.should be_kind_of( Phrase )
+    graph.value.should == value
+  end
+  
+  def should_be_mandatory(graph)
+    graph.should be_kind_of(MandatoryClause)
+    yield graph.operand if block_given?
+  end
+  def should_be_excluded(graph)
+    graph.should be_kind_of(ExcludedClause)
+    yield graph.operand if block_given?
+  end
+  def should_be_not_expression(graph)
+    graph.should be_kind_of(NotExpression)
+    yield graph.operand if block_given?
+  end
+end
+
+describe "NestingParser" do
+ describe "Building an Object parse tree" do
+    include ParseTreeSpecHelper
+        
+    
+    it "should build for term list" do
+      should_be_list parse("one two three")  do |list|
+        list.length.should == 3
+        should_be_term list[0], "one"
+        should_be_term list[1], "two"
+        should_be_term list[2], "three"        
+      end            
+    end
+    
+    it "should build AND list" do
+      should_be_and_list parse_one_element("one AND two AND three") do |list|
+        list.length.should == 3
+        
+        should_be_term list[0], "one"
+        should_be_term list[1], "two"
+        should_be_term list[2], "three"        
+      end
+    end
+    
+    it "should build OR list" do
+      should_be_or_list parse_one_element("one OR two OR three") do |list|        
+        list.length.should == 3
+        should_be_term list[0], "one"
+        should_be_term list[1], "two"
+        should_be_term list[2], "three"                  
+      end                  
+    end
+    
+    it "allows AND list of lists" do
+      should_be_and_list parse_one_element('(one two) AND (blue yellow)') do |and_list|
+        and_list.length.should == 2
+        should_be_list and_list[0] do |list|
+          should_be_term(list[0], "one")
+          should_be_term(list[1], "two")
+        end
+        should_be_list and_list[1]
+      end      
+    end
+    
+    it "should build for mandatory and excluded" do
+      should_be_list parse("+one -two") do |list|
+        list.length.should == 2
+        
+        should_be_mandatory list[0] do |operand|
+          should_be_term(operand, "one")
+        end
+        
+        should_be_excluded list[1] do |operand|
+          should_be_term(operand, "two")
+        end
+      end            
+    end
+    
+    it "should build phrases" do
+      should_be_list parse('"quick brown" +"jumps over" -"lazy dog"') do |list|
+        list.length.should == 3
+        
+        should_be_phrase(list[0], "quick brown")
+      
+        should_be_mandatory(list[1]) do |operand|
+          should_be_phrase(operand, "jumps over")
+        end  
+      end
+    end
+    
+    it "should leave phrase literals literal, including weird chars" do
+      phrase_content = "foo+bar -i: '(baz" 
+      should_be_phrase parse_one_element("\"#{phrase_content}\""), phrase_content      
+    end
+    
+    it "should build for NOT on term" do
+      should_be_list parse("one two three NOT four") do |list|
+        should_be_not_expression list[3] do |operand|
+          should_be_term(operand, "four")
+        end
+      end            
+    end
+    
+    it "should build for NOT on phrase" do
+      should_be_list parse('one two three NOT "quick brown"') do |list|
+        should_be_not_expression list[3] do |operand|
+          should_be_phrase(operand, "quick brown")
+        end
+      end      
+    end
+    
+    it "should build NOT on expression" do
+      should_be_list parse('one two NOT (blue OR yellow)') do |list|
+        should_be_not_expression list[2] do |operand|
+          should_be_or_list(operand)
+        end
+      end            
+    end
+    
+    it "should build NOT preceded by binary op" do
+      should_be_or_list parse_one_element('one OR NOT two') do |list|
+        should_be_not_expression list[1] do |operand|
+          should_be_term(operand, "two")
+        end
+      end              
+    end
+      
+    
+    it "should bind OR more tightly than AND" do
+      should_be_and_list parse_one_element("grey AND big OR small AND tail") do |list|        
+        list.length.should == 3
+        
+        should_be_term list[0], "grey"
+        
+        should_be_or_list list[1] do |or_list|
+            or_list.length.should == 2
+            should_be_term or_list[0], "big"
+            should_be_term or_list[1], "small"         
+        end
+        
+        should_be_term list[2], "tail"
+      end      
+    end
+    
+    it "should parse AND'd lists" do      
+      should_be_and_list parse_one_element("(foo bar one AND two) AND (three four ten OR twelve)") do |list|                
+        list.length.should == 2        
+        
+        should_be_list(list[0]) do |first_half|
+          first_half[0].value.should == 'foo'
+          first_half[1].value.should == "bar"
+          should_be_and_list(first_half[2])          
+        end
+        
+        should_be_list(list[1]) do |second_half|
+          second_half[0].value.should == "three"
+          second_half[1].value.should == "four"
+          should_be_or_list second_half[2]          
+        end
+      end
+    end
+    
+    it "should build for a crazy complicated one" do
+      should_be_list parse("mark +twain AND huck OR fun OR ((jim AND river) AND (red -dogs))") do |list|
+        should_be_term list[0], "mark"
+        should_be_and_list list[1] do |and_list|
+          
+          should_be_mandatory and_list[0] do |operand|
+            should_be_term operand, "twain"
+          end
+                                        
+          should_be_or_list and_list[1] do |or_list|
+            should_be_term or_list[0], "huck"
+            should_be_term or_list[1], "fun"
+            
+            should_be_and_list or_list[2] do |and_list|
+              and_list.length.should == 2
+              
+              should_be_and_list and_list[0]
+              
+              should_be_list and_list[1] do |terms|
+                should_be_term terms[0], "red"
+                should_be_excluded terms[1] do |operand|
+                  should_be_term operand, "dogs"
+                end
+              end
+            end
+            
+          end
+        end
+      end
+    end
+    
+  end
+end
+
+

data/spec/parsing_nesting/consuming_spec.rb

@@ -0,0 +1,49 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+#require 'rubygems'
+#require 'parslet'
+#require 'spec'
+#require 'spec/autorun'
+
+#load '../../nesting_parser/grammar.rb'
+#load '../../nesting_parser/tree.rb'
+
+describe "NestingParser" do
+  describe "Consuming" do
+    before do
+      @parser = ParsingNesting::Grammar.new
+    end
+    # Whole bunch of things we just want to make sure they are consumed
+    # without error, not checking the generated tree yet. 
+    ["foo",
+     "foo bar",
+     " foo bar ",
+     " foo bar   baz    ",
+     "+foo",
+     "-foo",
+     "+foo -bar",
+     "one +two three -four five",
+     "foo AND bar",
+     "one AND two AND three AND four",
+     "one OR two OR three OR four",
+     "white OR blue AND big OR small",
+     "+yes AND book OR -online",
+     "(one AND two)",
+     "  (  one   AND     two     )  ",
+     "(one OR two) three +four",
+     "(one AND two) OR three",
+     "(one AND -two) AND (+three OR (-four AND five))",
+     "one two three NOT four",
+     "one two three NOT (four OR five)",
+     "NOT four",
+     "NOT (four five)",
+     "(one two three) OR (four five) AND six",
+     '"foo+bar (baz"',
+     "(foo bar one AND two) AND (three four ten OR twelve)"
+    ].each do |query|
+      it "should consume<<#{query}>>" do
+        lambda {@parser.parse(query)}.should_not raise_error
+      end
+    end
+  end
+end
+

data/spec/parsing_nesting/to_solr_spec.rb

@@ -0,0 +1,360 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+#require 'rubygems'
+#require 'parslet'
+#require 'spec'
+#require 'spec/autorun'
+
+#load '../../lib/parsing_nesting/grammar.rb'
+#load '../../lib/parsing_nesting/tree.rb'
+
+module SolrQuerySpecHelper
+  def parse(s)
+    ParsingNesting::Tree.parse(s)
+  end
+  
+  # yields localparam string, and the actual internal query
+  def local_param_match(query)
+    query.should =~ /^ *_query_:\"\{([^}]+)\}(.*)" *$/
+    query =~ /^ *_query_:\"\{([^}]+)\}(.*)" *$/
+    (param_str = $1).should_not be_nil
+    (query = $2).should_not be_nil
+    
+    yield [param_str, query] if block_given?
+  end
+  
+  def bare_local_param_match(query)
+    query.should =~ / *\{([^}]+)\}(.*)/
+    query =~ /\{([^}]+)\}(.*)/
+    (param_str = $1).should_not be_nil
+    (query = $2).should_not be_nil
+    yield [param_str, query] if block_given?
+  end
+  
+  # Convenience for matching a lucene query combining nested queries,
+  # and getting out the nested queries as matches. 
+  # pass in a string representing a regexp that uses $QUERY as placeholder where
+  # a nested _query_: will be. 
+  #
+  # * Any parens in your passed in regexp will
+  # be paren literals, don't escape em yourself -- you can't do your
+  # own captures, because if the regexp passes, it'll yield to a block
+  # with a list, in order, of nested queries.
+  #  
+  #
+  # * Can include $ALL to represent literal "*:*"
+  #
+  # Yes, the regexp matching isn't as robust as it could be, hard
+  # to deal with like escaped end-quotes and stuff in a regexp, but
+  # should mostly work.   
+  def query_template_matcher(top_query, regexp_str)
+    nested_re = '(_query_:".+")'
+    regexp_str = regexp_str.gsub("(", '\(').gsub(')', '\)').gsub("$QUERY", nested_re).gsub("$ALL", "\\*\\:\\*")
+    regexp = Regexp.new('^ *' + regexp_str + ' *$')
+
+    top_query.should match( regexp )
+    
+    yield *regexp.match(top_query).captures if block_given?    
+  end
+end
+
+describe "NestingParser" do
+    describe "Translating to Solr" do
+    include SolrQuerySpecHelper
+       
+    describe "with basic simple query" do
+      before do
+        @query = parse("one two three").to_query(:qf => "field field2^5", :pf=>"$pf_title")
+      end
+      
+      it "should insist on dismax for nested query" do
+        query = parse("one two three").to_query(:defType => "field", :qf=>"$qf")
+        local_param_match(query) do |params, query|
+          params.should match(/^\!dismax /)
+          params.should_not match(/field/)
+        end
+      end
+      
+      it "should include LocalParams" do
+        local_param_match(@query) do |params, query|
+          params.should include("pf=$pf_title")
+          params.should include('qf=\'field field2^5\'')          
+        end                
+      end
+      
+      it "should include the query" do
+        local_param_match(@query) do |params, query|
+          query.should == "one two three"
+        end
+      end
+    end
+    
+    describe "with simple mandatory/excluded terms" do
+      before do
+        @inner_query = 'red +army -"soviet union" germany'
+        @full_query = parse(@inner_query).to_query(:qf => "foo", :pf=>"bar")
+      end
+      it "should include query" do
+        local_param_match(@full_query) do |params, query|
+          query.should == @inner_query.gsub('"', '\\\\"')
+        end
+      end
+    end
+    
+    describe "with embeddable AND query" do
+      before do
+        @query = parse("one two AND three").to_query({:qf => "$qf"})
+      end
+      it "should flatten to one dismax query" do
+        local_param_match(@query) do |params, query|
+          query.should == "one +two +three"
+        end
+      end
+      
+      describe ", with mandatory/excluded" do
+        before do
+          @query = parse("one -two AND +three").to_query({:qf=>"$qf"})
+        end
+        it "should preserve +/- operators" do
+          local_param_match(@query) do |params, query|
+            query.should == "one -two +three"
+          end
+        end
+      end
+      
+      describe ", deeply nested" do
+        before do
+          @query = parse("blue (green AND -violet) AND (+big AND (-small AND medium))").to_query({:qf=>"$qf"})
+        end
+        it "should flatten into dismax" do
+          local_param_match(@query) do |params, query|
+            query.should == "blue +green -violet +big -small +medium"
+          end
+        end
+      end     
+      
+      it "for simple OR list, forcing mm=1" do
+        query = parse("one OR two OR three").to_query(:qf => "$qf", :mm=>"50%")        
+        local_param_match(query) do |params, query|
+          params.should include("mm=1")
+          query.should == "one two three"
+        end                
+      end
+    end
+   
+    
+    describe "that needs to create multiple nested queries" do
+
+      
+      it "for two lists, OR'd" do
+        query = parse("(one two three) OR (red -green +blue)").to_query(:qf => "$qf")  
+        
+        query_template_matcher(query, "( *$QUERY +OR +$QUERY *)" ) do |first_half, second_half|
+                
+          local_param_match(first_half) do |params, query|
+            params.should include("qf=$qf")
+            query.should == "one two three"
+          end
+          
+          local_param_match(second_half) do |params, query|
+            params.should include("qf=$qf")
+            query.should == "red -green +blue"
+          end
+        end
+      end
+      
+      it "for AND list that can not be flattened" do
+        params = {:qf=>"$qf", :pf=>"$pf", :mm=>"50%"}
+        query = parse("a OR b AND x OR y").to_query( params )
+        
+        query_template_matcher(query, "( *$QUERY +AND +$QUERY *)" ) do |first, second|                
+          first.should == parse("a OR b").to_query(params)
+          second.should == parse("x OR y").to_query(params)
+        end
+      end
+      
+      it "for AND of two lists" do
+        params = {:qf => "$qf", :pf=>"$pf", :mm=>"50%"}
+        query = parse("(one +two three) AND (four five -six)").to_query( params )
+                
+        query_template_matcher(query, "( *$QUERY +AND +$QUERY *)" ) do |first, second|
+          first.should == parse("one +two three").to_query(params)
+          second.should == parse("four five -six").to_query(params)          
+        end
+                
+      end
+      
+      it "for crazy complicated query" do
+        query = parse("red AND dawn OR (-night -afternoon) AND NOT (moscow OR beach) ").to_query(:qf => "$qf", :pf =>"$pf", :mm=>"50%")
+        
+        query_template_matcher(query, "( *$QUERY +AND +( *$QUERY +OR +($ALL AND NOT $QUERY *) *) +AND NOT $QUERY *)") do |red_q, dawn_q, night_q, moscow_q|
+        
+          local_param_match(red_q) { |params, query| query.should == "red" }            
+        
+          local_param_match(dawn_q) { |params, query| query.should == "dawn"}
+          
+          local_param_match(night_q) do |params, query|
+            params.should include("mm=1")
+            query.should == "night afternoon"
+          end
+          
+          local_param_match(moscow_q) do |params, query|
+            params.should include("mm=1")
+            query.should == "moscow beach"
+          end
+        
+        end
+                
+      end
+      
+      
+    end
+    
+    describe "for NOT operator" do
+      it "simple" do
+        query = parse("NOT frog").to_query
+          
+        query_template_matcher(query, "NOT $QUERY") do |q|
+          q.should == parse("frog").to_query
+        end                    
+      end
+      it "binds tightly" do
+        query = parse("one NOT two three").to_query
+       
+        query_template_matcher(query, "$QUERY AND NOT $QUERY") do |q1, q2|
+          
+          local_param_match(q1) do |params, query|
+            query.should == "one three"
+          end
+          
+          local_param_match(q2) do |params, query|
+            query.should == "two"
+          end
+        end
+        
+      end
+      it "complicated operand" do
+        query = parse("one OR two NOT (three OR four AND five)").to_query
+        #"_query_:'{!dismax mm=1}one two' AND NOT ( _query_:'{!dismax mm=1}three four' AND _query_:'{!dismax }five' )"
+        query_template_matcher(query, "$QUERY +AND NOT +( *$QUERY +AND +$QUERY *)") do |external_or, internal_or, internal_term|
+          external_or.should == parse("one OR two").to_query
+          internal_or.should == parse("three OR four").to_query 
+          internal_term.should == parse("five").to_query 
+        end        
+      end
+      
+      it "uses workaround on NOT as operand to OR" do
+        query = parse("two OR (NOT (three))").to_query
+        query_template_matcher(query, "( *$QUERY +OR +($ALL +AND +NOT +$QUERY) *)")        
+      end
+      
+    end
+    
+    describe "for pure negative" do
+      it "should convert simple pure negative" do
+        query = parse('-one -two -"a phrase"').to_query(:qf => "$qf", :mm => "100%")
+        
+        query_template_matcher(query, " *NOT $QUERY") do |query|
+          local_param_match(query) do |params, query|
+            params.should include("mm=1")
+            query.should == 'one two \\"a phrase\\"'
+          end
+        end
+        
+      end
+      
+      it "should convert pure negative AND" do
+        query = parse("-one AND -two AND -three").to_query(:qf => "$qf", :mm => "100%")
+        
+        query_template_matcher(query, "NOT $QUERY") do |query|
+          local_param_match(query) do |params, query|
+            params.should =~ /mm=1 |$/
+            query.should == 'one two three'
+          end
+        end
+      end
+      
+      it "should convert pure negative OR" do
+        query = parse("-one OR -two OR -three").to_query        
+        
+        query_template_matcher(query, "NOT $QUERY") do |query|
+          local_param_match(query) do |params, query|
+            params.should include("mm=100%")
+            query.should == "one two three"
+          end
+        end
+
+      end
+      
+      it "should convert crazy pure negative combo" do        
+        query = parse("(-one -two) OR -three OR (-five AND -six)").to_query
+        
+        query_template_matcher(query, "( *($ALL +AND +NOT +$QUERY) +OR +( *$ALL +AND +NOT +$QUERY *) +OR +( *$ALL +AND +NOT +$QUERY *) *)")                
+      end
+    end
+    
+    
+    # When a single parse will be the whole query, we use
+    # different more compact production
+    describe "Single Query" do
+      before do
+        @solr_local_params = {"qf" => "$title_qf", "pf" => "$title_pf"}
+      end
+      describe "simple search" do
+        it "should work with local params" do
+          hash = parse("one +two -three").to_single_query_params(@solr_local_params)
+          hash[:defType].should == "dismax"
+          bare_local_param_match(hash[:q]) do |params, query|
+            query.should == "one +two -three"
+            params.should include("pf=$title_pf")
+            params.should include("qf=$title_qf")
+          end
+        end
+        
+        it "should work without local params" do
+          hash = parse("one +two -three").to_single_query_params({})
+          hash[:defType].should == "dismax"
+          hash[:q].should == "one +two -three"          
+        end
+      end
+      describe "simple pure negative" do
+        it "should be nested NOT" do
+          hash = parse("-one -two").to_single_query_params({})
+          hash[:defType].should == "dismax"
+          query_template_matcher(hash[:q], "NOT $QUERY") do |query|
+            local_param_match(query) do |params, query|
+              query.should == "one two"
+              params.should include("mm=1")
+            end            
+          end
+        end
+      end
+      describe "complex query" do
+        it "should parse" do
+          hash = parse("one AND (two OR three)").to_single_query_params({})
+          hash[:defType].should == "lucene"
+          query_template_matcher(hash[:q], "( *$QUERY +AND +$QUERY *)") do |first, second|
+            local_param_match(first) do |params, query|
+              params.should include("dismax")
+              query.should == "one"
+            end
+            local_param_match(second) do |params, query|
+              params.should include("mm=1")
+              params.should include("dismax")
+              query.should == "two three"
+            end
+          end
+        end
+      end
+      
+      
+    end  
+
+    
+  end
+  
+  
+  
+  
+end
+
+

data/spec/rcov.opts

@@ -0,0 +1,3 @@
+--exclude "spec/*,gems/*,features/*"
+--rails
+--aggregate coverage.data

data/spec/spec.opts

@@ -0,0 +1,4 @@
+--colour
+--format progress
+--loadby mtime
+--reverse

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+#RAILS_ROOT = "#{File.dirname(__FILE__)}/.."
+
+Dir[Pathname.new(File.expand_path("../support/**/*.rb", __FILE__))].each {|f| require f}
+require 'lib/blacklight_advanced_search'
+
+RSpec.configure do |config|
+
+end
+

data/spec/support/blacklight_mock.rb

@@ -0,0 +1,5 @@
+module Blacklight
+  module SearchFields
+
+  end
+end

data/uninstall.rb

@@ -0,0 +1 @@
+# Uninstall hook code here