scoped_search 2.0.1

data/spec/lib/database.rb

@@ -0,0 +1,49 @@
+ActiveRecord::Migration.verbose = false unless ENV.has_key?('DEBUG')
+
+module ScopedSearch::Spec::Database
+
+  def self.establish_connection
+    if ENV['DATABASE']
+      self.establish_named_connection(ENV['DATABASE'])
+    else
+      self.establish_default_connection
+    end
+  end
+
+  def self.test_databases
+    @database_connections ||= YAML.load(File.read("#{File.dirname(__FILE__)}/../database.yml"))
+    @database_connections.keys
+  end
+
+  def self.establish_named_connection(name)
+    @database_connections ||= YAML.load(File.read("#{File.dirname(__FILE__)}/../database.yml"))
+    raise "#{name} database not configured" if @database_connections[name.to_s].nil?
+    ActiveRecord::Base.establish_connection(@database_connections[name.to_s])
+  end
+
+  def self.establish_default_connection
+    ActiveRecord::Base.establish_connection(:adapter => 'sqlite3', :database => ':memory:')
+  end
+
+  def self.close_connection
+    ActiveRecord::Base.remove_connection
+  end
+
+  def self.create_model(fields)
+    table_name = "model_#{rand}".gsub(/\./, '')
+    ActiveRecord::Migration.create_table(table_name) do |t|
+      fields.each do |name, field_type|
+        t.send(field_type.to_s.gsub(/^unindexed_/, '').to_sym, name)
+      end
+    end
+
+    klass = Class.new(ActiveRecord::Base)
+    klass.set_table_name(table_name)
+    yield(klass) if block_given?
+    return klass
+  end
+
+  def self.drop_model(klass)
+    ActiveRecord::Migration.drop_table(klass.table_name)
+  end
+end

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,19 @@
+$:.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'rubygems'
+require 'spec'
+require 'active_record'
+
+require 'scoped_search'
+
+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,104 @@
+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