wvanbergen-scoped_search 1.2.0 → 2.0.0

data/spec/lib/matchers.rb

@@ -0,0 +1,40 @@
+module ScopedSearch::Spec::Matchers
+  def be_infix_operator(operator = nil)
+    simple_matcher('node to be an infix operator') do |node|
+      node.kind_of?(ScopedSearch::QueryLanguage::AST::OperatorNode) &&
+          node.infix? && (operator.nil? || operator == node.operator)
+    end
+  end
+
+  def be_prefix_operator(operator = nil)
+    simple_matcher('node to be an prefix operator') do |node|
+      node.kind_of?(ScopedSearch::QueryLanguage::AST::OperatorNode) &&
+          node.prefix? && (operator.nil? || operator == node.operator)
+    end
+  end
+
+  def be_logical_operator(operator = nil)
+    simple_matcher('node to be an logical operator') do |node|
+      node.kind_of?(ScopedSearch::QueryLanguage::AST::LogicalOperatorNode) &&
+          (operator.nil? || operator == node.operator)
+    end
+  end
+  
+  def be_leaf_node(value = nil)
+    simple_matcher('node to be an logical operator') do |node|
+      node.kind_of?(ScopedSearch::QueryLanguage::AST::LeafNode) && (value.nil? || value == node.value)
+    end 
+  end
+  
+  def tokenize_to(*tokens) 
+    simple_matcher("to tokenize to #{tokens.inspect}") do |string|
+      tokens == ScopedSearch::QueryLanguage::Compiler.tokenize(string)
+    end
+  end 
+
+  def parse_to(tree)
+    simple_matcher("to parse to #{tree.inspect}") do |string|
+      tree == ScopedSearch::QueryLanguage::Compiler.parse(string).to_a 
+    end    
+  end
+end

data/spec/lib/mocks.rb

@@ -0,0 +1,19 @@
+module ScopedSearch::Spec::Mocks
+
+  def tree(array)
+    ScopedSearch::QueryLanguage::AST.from_array(array)
+  end
+
+  def mock_activerecord_class
+    ar_mock = mock('ActiveRecord::Base')
+    ar_mock.stub!(:named_scope).with(:search_for, anything)
+    ar_mock.stub!(:connection).and_return(mock_database_connection)
+    return ar_mock
+  end
+  
+  def mock_database_connection
+    c_mock = mock('ActiveRecord::Base.connection')
+    return c_mock
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+$:.reject! { |e| e.include? 'TextMate' }
+$: << File.join(File.dirname(__FILE__), '..', 'lib')
+
+require 'rubygems'
+require 'spec'
+require 'active_record'
+
+require 'scoped_search'
+require 'scoped_search/query_language'
+
+module ScopedSearch::Spec; end
+
+require "#{File.dirname(__FILE__)}/lib/matchers"
+require "#{File.dirname(__FILE__)}/lib/database"
+require "#{File.dirname(__FILE__)}/lib/mocks"
+
+
+Spec::Runner.configure do |config|
+  config.include ScopedSearch::Spec::Matchers
+  config.include ScopedSearch::Spec::Mocks
+end

data/spec/unit/ast_spec.rb

@@ -0,0 +1,197 @@
+require "#{File.dirname(__FILE__)}/../spec_helper"
+
+describe ScopedSearch::QueryLanguage::AST do
+
+  describe '.from_array' do
+
+    context 'parsing a singular value' do
+      before(:each) do
+        @ast = ScopedSearch::QueryLanguage::AST.from_array('value')
+      end
+
+      it "should create a leaf node for a normal value" do
+        @ast.should be_leaf_node('value')
+      end
+    end
+
+    context 'parsing a prefix operator' do
+      before(:each) do
+        @ast = ScopedSearch::QueryLanguage::AST.from_array([:not, 'a'])
+      end
+
+      it "should create a operator node for an array starting with an operator" do
+        @ast.should be_prefix_operator(:not)
+      end
+
+      it "should create a child node for every subsequent array item" do
+        @ast.should have(1).children
+      end
+
+      it "should create set the RHS the the first child value" do
+        @ast.rhs.should be_leaf_node('a')
+      end
+    end
+
+    context 'pasring an infix operator' do
+      before(:each) do
+        @ast = ScopedSearch::QueryLanguage::AST.from_array([:eq, 'a', 'b'])
+      end
+
+      it "should create a operator node for an array starting with an operator" do
+        @ast.should be_infix_operator(:eq)
+      end
+
+      it "should create a child node for every subsequent array item" do
+        @ast.should have(2).children
+      end
+
+      it "should create set the LHS the the first child value" do
+        @ast.lhs.should be_leaf_node('a')
+      end
+
+      it "should create set the RHS the the second child value" do
+        @ast.rhs.should be_leaf_node('b')
+      end
+    end
+
+    context 'parsing a nested logical construct' do
+      before(:each) do
+        @ast = ScopedSearch::QueryLanguage::AST.from_array([:and, 'a', [:or, 'b', [:not, 'c']]])
+      end
+
+      it "should create a logical operator node for an array starting with :and" do
+        @ast.should be_logical_operator(:and)
+      end
+
+      it "should create a child node for every subsequent array item" do
+        @ast.should have(2).children
+      end    
+
+      it "should create a nested OR structure for a nested array" do
+        @ast.lhs.should be_leaf_node('a')
+      end
+
+      it "should create a nested OR structure for a nested array" do
+        @ast.rhs.should be_logical_operator(:or)
+      end
+
+      it "should create a leaf node in the nested OR structure" do
+        @ast.rhs.lhs.should be_leaf_node('b')
+      end
+
+      it "should create a NOT operator in the nested OR structure" do
+        @ast.rhs.rhs.should be_prefix_operator(:not)
+      end
+
+      it "should create a leaf node in the nested OR structure" do
+        @ast.rhs.rhs.rhs.should be_leaf_node('c')
+      end
+    end
+  end
+
+  # Recursive tree simplification algorithm
+  describe '#simplify' do
+
+    it "should not simplify a leaf node" do
+      tree('value').simplify.should eql(tree('value'))
+    end
+
+    it "should not simplify a prefix operator node node" do
+      tree([:lt, '1']).simplify.should eql(tree([:lt, '1']))
+    end
+
+    it "should not simplify an infix operator node node" do
+      tree([:lt, 'field', '1']).simplify.should eql(tree([:lt, 'field', '1']))
+    end
+
+    it "should simplify a single value in a logical operator" do
+      tree([:and, 'a']).simplify.should eql(tree('a'))
+    end
+
+    it "should simplify a single operator in a logical operator" do
+      tree([:or, [:gt, '2']]).simplify.should eql(tree([:gt, '2']))
+    end
+
+    it "should not simplify a logical operator with multiple values" do
+      tree([:and, 'a', 'b']).simplify.should eql(tree([:and, 'a', 'b']))
+    end
+
+    it "should simplify nested logial operators" do
+      tree([:and, [:and, 'a', 'b'], [:and, 'c']]).simplify.should eql(tree([:and, 'a', 'b', 'c']))
+    end
+
+    it "should simplify double nested logial operators" do
+      tree([:and, [:and, 'a', [:and, 'b', 'c']]]).simplify.should eql(tree([:and, 'a', 'b', 'c']))
+    end
+
+    it "should not simplify nested operators if the operators are different" do
+      tree([:or, 'a', [:and, 'b', 'c']]).simplify.should eql(tree([:or, 'a', [:and, 'b', 'c']]))
+    end
+  end
+end
+
+describe ScopedSearch::QueryLanguage::AST::OperatorNode do
+
+  context 'with 1 child' do
+    before(:each) do
+      @node = tree([:not, '1']) 
+    end
+
+    it 'should be a prefix operator' do
+      @node.should be_prefix
+    end
+
+    it "should not be an infix operator" do
+      @node.should_not be_infix
+    end
+
+    it 'should return the first child as RHS' do
+      @node.rhs.should eql(@node[0])
+    end
+
+    it "should raise an error of the LHS is requested" do
+      lambda { @node.lhs }.should raise_error
+    end
+  end
+
+  context 'with 2 children' do
+    before(:each) do
+      @node = tree([:eq, '1', '2']) 
+    end
+
+    it "should be an infix operator" do
+      @node.should be_infix
+    end
+
+    it "should not be a prefix operator" do
+      @node.should_not be_prefix      
+    end
+
+    it "should return the first child as LHS" do
+      @node.lhs.should eql(@node[0])
+    end
+
+    it "should return the second child as RHS" do
+      @node.rhs.should eql(@node[1])
+    end
+
+  end
+
+  context 'many children' do
+    before(:each) do
+      @node = tree([:and, '1', '2', '3', '4']) 
+    end
+
+    it "should be an infix operator" do
+      @node.should be_infix
+    end
+
+    it "should raise an error of the LHS is requested" do
+      lambda { @node.lhs }.should raise_error
+    end
+
+    it "should raise an error of the RHS is requested" do
+      lambda { @node.rhs }.should raise_error
+    end
+  end
+end

data/spec/unit/definition_spec.rb

@@ -0,0 +1,24 @@
+require "#{File.dirname(__FILE__)}/../spec_helper"
+
+describe ScopedSearch::Definition do
+
+  before(:each) do
+    @klass      = mock_activerecord_class
+    @definition = ScopedSearch::Definition.new(@klass)
+    @definition.stub!(:setup_adapter)
+  end
+
+  describe '#initialize' do
+    
+    it "should create the named scope when" do
+      @klass.should_receive(:named_scope).with(:search_for, instance_of(Proc))
+      ScopedSearch::Definition.new(@klass)
+    end
+
+    it "should not create the named scope if it already exists" do
+      @klass.stub!(:search_for)
+      @klass.should_not_receive(:named_scope)
+      ScopedSearch::Definition.new(@klass)
+    end
+  end
+end

data/spec/unit/parser_spec.rb

@@ -0,0 +1,105 @@
+require "#{File.dirname(__FILE__)}/../spec_helper"
+
+describe ScopedSearch::QueryLanguage::Parser do
+        
+  it "should create a 1-node tree for a single keyword" do
+    'single'.should parse_to('single')
+  end
+  
+  it "should create a two-item AND construct for two keywords" do
+    'double_1 double_2'.should parse_to([:and, 'double_1', 'double_2'])    
+  end
+  
+  it "should create a three-item AND construct for three keywords" do
+    'triplet_1 triplet_2 triplet_3'.should parse_to([:and, 'triplet_1', 'triplet_2', 'triplet_3'])
+  end
+  
+  it "should create a four-item AND construct by simplifying AND constructs" do
+    '1 (2 (3 4))'.should parse_to([:and, '1', '2', '3', '4'])
+  end
+  
+  
+  it "should create an OR construct" do
+    'some OR simple OR keywords'.should parse_to([:or, 'some', 'simple', 'keywords'])
+  end
+
+  it "should nest an OR as second argument of the AND construct" do
+    'some simple OR keywords'.should parse_to([:and, 'some', [:or, 'simple', 'keywords']])
+  end
+  
+  it "should nest an OR as first argument of an AND construct" do
+    'some OR simple keywords'.should parse_to([:and, [:or, 'some', 'simple'], 'keywords'])
+  end
+  
+  it "should handle parenthesis as AND block, placed in an OR block" do
+    'some OR (simple keywords)'.should parse_to([:or, 'some', [:and, 'simple', 'keywords']])
+  end
+  
+  it "should handle parenthesis as OR block in an AND block" do
+    '(some OR simple) keywords'.should parse_to([:and, [:or, 'some', 'simple'], 'keywords'])
+  end
+  
+  it "should create a block for the NOT keyword" do
+    'not easy'.should parse_to([:not, 'easy'])
+  end
+
+  it "should create a nsted NOT block" do
+    'not !easy'.should parse_to([:not, [:not, 'easy']])
+  end
+  
+  it "should create a block for the NOT keyword in an AND block" do
+    'hard !easy'.should parse_to([:and, 'hard', [:not, 'easy']])
+  end
+  
+  it "should create a block for the NOT keyword in an OR block" do
+    'hard || !easy'.should parse_to([:or, 'hard', [:not, 'easy']])
+  end
+
+  it "should create a block for the NOT keyword in an OR block" do
+    '!easy OR !hard'.should parse_to([:or, [:not, 'easy'], [:not, 'hard']])
+  end
+  
+  it "should nest the NOT blocks correctly according to parantheses" do
+    '!(easy OR !hard)'.should parse_to([:not, [:or, 'easy', [:not, 'hard']]])
+  end
+  
+  it "should create OR blocks in an AND block" do
+    '(a|b)(b|c)'.should parse_to([:and, [:or, 'a', 'b'], [:or, 'b', 'c']])
+  end
+
+  it "should create OR blocks in an explicit AND block" do
+    '(a|b)&(b|c)'.should parse_to([:and, [:or, 'a', 'b'], [:or, 'b', 'c']])
+  end
+  
+  it "should ignore a comma under normal circumstances" do
+    'a,b'.should parse_to([:and, 'a', 'b'])
+  end
+  
+  it "should correctly parse an infix comparison" do
+    'a>b'.should parse_to([:gt, 'a', 'b'])
+  end
+
+  it "should correctly parse a prefix comparison" do
+    '<b'.should parse_to([:lt, 'b'])
+  end
+
+  it "should create a comparison in an AND block because of the comma delimiter" do
+    'a, < b'.should parse_to([:and, 'a', [:lt, 'b']])
+  end
+  
+  it "should create a infix and prefix comparison in an AND block because of parentheses" do
+    '(a = b) >c'.should parse_to([:and, [:eq, 'a', 'b'], [:gt, 'c']])
+  end
+
+  it "should create a infix and prefix comparison in an AND block because of a comma" do
+    'a = b, >c'.should parse_to([:and, [:eq, 'a', 'b'], [:gt, 'c']])
+  end
+
+  it "should create a infix and prefix comparison in an AND block because of first come first serve" do
+    'a = b > c'.should parse_to([:and, [:eq, 'a', 'b'], [:gt, 'c']])
+  end
+  
+  it "should parse a null? keyword" do
+    'set? a b null? c'.should parse_to([:and, [:notnull, 'a'], 'b', [:null, 'c']])
+  end
+end

data/spec/unit/query_builder_spec.rb

@@ -0,0 +1,5 @@
+require "#{File.dirname(__FILE__)}/../spec_helper"
+
+describe ScopedSearch::QueryBuilder do
+  it "should be specced"
+end

data/spec/unit/tokenizer_spec.rb

@@ -0,0 +1,97 @@
+require "#{File.dirname(__FILE__)}/../spec_helper"
+
+describe ScopedSearch::QueryLanguage::Tokenizer do
+  
+  it "should create tokens for strings" do
+    'some simple keywords'.should tokenize_to('some', 'simple', 'keywords')
+  end
+  
+  it "should ignore excessive whitespace" do
+    "  with\twhitespace   \n".should tokenize_to('with', 'whitespace')
+  end
+  
+  it "should leave quoted strings intact" do
+    '"quoted string"'.should tokenize_to("quoted string")
+  end
+  
+  it "should allow escaping quotes in quoted strings using a backslash" do
+    '"quoted \"string"'.should tokenize_to('quoted "string')
+  end
+  
+  it "should allow escaping the escape charachter" do
+    '"quoted \\\\string"'.should tokenize_to('quoted \\string')
+  end
+  
+  it "should handle unclosed quoted string gracefully" do
+    '"quoted string'.should tokenize_to("quoted string")
+  end
+  
+  it "should tokenize multiple quoted strings" do
+    '"quoted string"   "another"  '.should tokenize_to("quoted string", 'another')
+  end
+  
+  it "should tokenize multiple quoted strings without separating whitespace" do
+    '"quoted string""another"'.should tokenize_to("quoted string", 'another')
+  end
+
+  it "should tokenize combinations of quoted strings and unquoted strings" do
+    '"quoted string" another'.should tokenize_to("quoted string", 'another')
+  end
+
+  it "should tokenize combinations of quoted strings and unquoted strings without whitespace" do
+    '"quoted string"another'.should tokenize_to("quoted string", 'another')
+  end
+
+  it "should allow quotes in the middle of a normal string" do
+    'a"b'.should tokenize_to('a"b')
+  end
+  
+  it "should parse keyword characters" do
+    'a | -("b""c") & d'.should tokenize_to('a', :or, :not, :lparen, 'b', 'c', :rparen, :and, 'd')
+  end
+  
+  it "should tokenize null operators" do
+    'set? a null? b'.should tokenize_to(:notnull, 'a', :null, 'b')
+  end  
+
+  it "should parse double keyword characters" do
+    'a || b'.should tokenize_to('a', :or, 'b')
+  end
+  
+  it "should parse double keyword characters with whitespace as separate tokens" do
+    'a | | b'.should tokenize_to('a', :or, :or, 'b')
+  end
+  
+  it "should parse keyword strings" do
+    "a and b".should tokenize_to('a', :and, 'b')
+  end
+
+  it "should parse keyword strings with different capitalizations" do
+    "a AnD b".should tokenize_to('a', :and, 'b')
+  end
+
+  it "should not parse keyword strings when quoted" do
+    'a "and" b'.should tokenize_to('a', 'and', 'b')
+  end
+
+  it "should not parse a negation character within a string as NOT keyword" do
+    'a-b'.should tokenize_to('a-b')
+  end
+
+  it "should parse an AND operator within a string as separate token" do
+    'a&b'.should tokenize_to('a', :and, 'b')
+  end
+
+  it "should parse an OR operator within a string as separate token" do
+    'a||b'.should tokenize_to('a', :or, 'b')
+  end
+
+  it "should parse an equals operator within a string as separate token" do
+    'a=b'.should tokenize_to('a', :eq, 'b')
+  end
+  
+  it "should not parse an operator within a string as separate token when quoted" do
+    '"a=b"'.should tokenize_to('a=b')
+  end  
+  
+end