outoftime-sunspot 0.9.2 → 0.9.3

data/TODO

@@ -1,4 +1,9 @@
-=== 0.9 ===
-* Query-based faceting (?)
+=== 0.9.X ===
+* Deal with empty facet queries
+* Passing an integer into the second argument of dynamic_facet() when multiple facets are requested gives the wrong value
 === 0.10 ===
+* Highlighting
+* LocalSolr
+* Text field restrictions
+* Prefixes
 * Intelligently decide whether to instantiate all facet rows at once

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
-:patch: 2
+:patch: 3
 :major: 0
 :minor: 9

data/lib/sunspot/query/connective.rb

@@ -5,8 +5,8 @@ module Sunspot
       # Base class for connectives (conjunctions and disjunctions).
       #
       class Abstract < Scope
-        def initialize(setup) #:nodoc:
-          @setup = setup
+        def initialize(setup, negated = false) #:nodoc:
+          @setup, @negated = setup, negated
           @components = []
         end
 
@@ -21,7 +21,7 @@ module Sunspot
         # Express the connective as a Lucene boolean phrase.
         #
         def to_boolean_phrase #:nodoc:
-          if @components.length == 1
+          phrase = if @components.length == 1
             @components.first.to_boolean_phrase
           else
             component_phrases = @components.map do |component|
@@ -29,6 +29,11 @@ module Sunspot
             end
             "(#{component_phrases.join(" #{connector} ")})"
           end
+          if negated?
+            "-#{phrase}"
+          else
+            phrase
+          end
         end
 
         # 
@@ -38,12 +43,38 @@ module Sunspot
         def add_component(component) #:nodoc:
           @components << component
         end
+
+        def negated?
+          @negated
+        end
+
+        def negate
+          negated = self.class.new(@setup, !negated?)
+          for component in @components
+            negated.add_component(component)
+          end
+          negated
+        end
       end
 
       # 
       # Disjunctions combine their components with an OR operator.
       #
       class Disjunction < Abstract
+        class <<self
+          def inverse
+            Conjunction
+          end
+        end
+
+        def to_boolean_phrase
+          if @components.any? { |component| component.negated? }
+            denormalize.to_boolean_phrase
+          else
+            super
+          end
+        end
+
         # 
         # Add a conjunction to the disjunction. This overrides the method in
         # the Scope class since scopes are implicitly conjunctive and thus
@@ -55,17 +86,35 @@ module Sunspot
           conjunction
         end
 
+        def add_disjunction
+          self
+        end
+
         private
 
         def connector
           'OR'
         end
+
+        def denormalize
+          denormalized = self.class.inverse.new(@setup, !negated?)
+          for component in @components
+            denormalized.add_component(component.negate)
+          end
+          denormalized
+        end
       end
 
       # 
       # Conjunctions combine their components with an AND operator.
       #
       class Conjunction < Abstract
+        class <<self
+          def inverse
+            Disjunction
+          end
+        end
+
         private
 
         def connector

data/lib/sunspot/query/restriction.rb

@@ -26,17 +26,17 @@ module Sunspot
       # API for instances of this class.
       #
       # Implementations of this class must respond to #to_params and
-      # #to_negative_params. Instead of implementing those methods, they may
+      # #to_negated_params. Instead of implementing those methods, they may
       # choose to implement any of:
       #
-      # * #to_positive_boolean_phrase, and optionally #to_negative_boolean_phrase
+      # * #to_positive_boolean_phrase, and optionally #to_negated_boolean_phrase
       # * #to_solr_conditional
       #
       class Base #:nodoc:
         include RSolr::Char
 
-        def initialize(field, value, negative = false)
-          @field, @value, @negative = field, value, negative
+        def initialize(field, value, negated = false)
+          @field, @value, @negated = field, value, negated
         end
 
         # 
@@ -56,14 +56,14 @@ module Sunspot
 
         # 
         # Return the boolean phrase associated with this restriction object.
-        # Differentiates between positive and negative boolean phrases depending
+        # Differentiates between positive and negated boolean phrases depending
         # on whether this restriction is negated.
         #
         def to_boolean_phrase
-          unless negative?
+          unless negated?
             to_positive_boolean_phrase
           else
-            to_negative_boolean_phrase
+            to_negated_boolean_phrase
           end
         end
 
@@ -85,27 +85,31 @@ module Sunspot
         end
 
         # 
-        # Boolean phrase representing this restriction in the negative. Subclasses
+        # Boolean phrase representing this restriction in the negated. Subclasses
         # may choose to implement this method, but it is not necessary, as the
         # base implementation delegates to #to_positive_boolean_phrase.
         #
         # ==== Returns
         #
-        # String:: Boolean phrase for restriction in the negative
+        # String:: Boolean phrase for restriction in the negated
         #
-        def to_negative_boolean_phrase
+        def to_negated_boolean_phrase
           "-#{to_positive_boolean_phrase}"
         end
 
-        protected
-
         # 
         # Whether this restriction should be negated from its original meaning
         #
-        def negative?
-          !!@negative
+        def negated? #:nodoc:
+          !!@negated
+        end
+
+        def negate
+          self.class.new(@field, @value, !@negated)
         end
 
+        protected
+
         # 
         # Return escaped Solr API representation of given value
         #
@@ -136,7 +140,7 @@ module Sunspot
           end
         end
 
-        def to_negative_boolean_phrase
+        def to_negated_boolean_phrase
           unless @value.nil?
             super
           else
@@ -211,14 +215,18 @@ module Sunspot
       # Result must be the exact instance given (only useful when negated).
       #
       class SameAs < Base
-        def initialize(object, negative = false)
-          @object, @negative = object, negative
+        def initialize(object, negated = false)
+          @object, @negated = object, negated
         end
 
         def to_positive_boolean_phrase
           adapter = Adapters::InstanceAdapter.adapt(@object)
           "id:#{escape(adapter.index_id)}"
         end
+
+        def negate
+          SameAs.new(@object, !@negated)
+        end
       end
     end
   end

data/spec/api/build_search_spec.rb

@@ -288,7 +288,85 @@ describe 'Search' do
       end
     end
     connection.should have_last_search_with(
-      :fq => '(category_ids_im:1 OR -average_rating_f:[3\.0 TO *])'
+      :fq => '-(-category_ids_im:1 AND average_rating_f:[3\.0 TO *])'
+    )
+  end
+
+  it 'should create a disjunction with nested conjunction with negated restrictions' do
+    session.search Post do
+      any_of do
+        with :category_ids, 1
+        all_of do
+          without(:average_rating).greater_than(3.0)
+          with(:blog_id, 1)
+        end
+      end
+    end
+    connection.should have_last_search_with(
+      :fq => '(category_ids_im:1 OR (-average_rating_f:[3\.0 TO *] AND blog_id_i:1))'
+    )
+  end
+
+  it 'should create a disjunction with nested conjunction with nested disjunction with negated restriction' do
+    session.search(Post) do
+      any_of do
+        with(:title, 'Yes')
+        all_of do
+          with(:blog_id, 1)
+          any_of do
+            with(:category_ids, 4)
+            without(:average_rating, 2.0)
+          end
+        end
+      end
+    end
+    connection.should have_last_search_with(
+      :fq => '(title_ss:Yes OR (blog_id_i:1 AND -(-category_ids_im:4 AND average_rating_f:2\.0)))'
+    )
+  end
+
+  it 'should create a disjunction with a negated restriction and a nested disjunction in a conjunction with a negated restriction' do
+    session.search(Post) do
+      any_of do
+        without(:title, 'Yes')
+        all_of do
+          with(:blog_id, 1)
+          any_of do
+            with(:category_ids, 4)
+            without(:average_rating, 2.0)
+          end
+        end
+      end
+    end
+    connection.should have_last_search_with(
+      :fq => '-(title_ss:Yes AND -(blog_id_i:1 AND -(-category_ids_im:4 AND average_rating_f:2\.0)))'
+    )
+  end
+
+  #
+  # This is important because if a disjunction could be nested in another
+  # disjunction, then the inner disjunction could denormalize (and thus
+  # become negated) after the outer disjunction denormalized (checking to
+  # see if the inner one is negated). Since conjunctions never need to
+  # denormalize, if a disjunction can only contain conjunctions or restrictions,
+  # we can guarantee that the negation state of a disjunction's components will
+  # not change when #to_params is called on them.
+  #
+  # Since disjunction is associative, this behavior has no effect on the actual
+  # logical semantics of the disjunction.
+  #
+  it 'should create a single disjunction when disjunctions nested' do
+    session.search(Post) do
+      any_of do
+        with(:title, 'Yes')
+        any_of do
+          with(:blog_id, 1)
+          with(:category_ids, 4)
+        end
+      end
+    end
+    connection.should have_last_search_with(
+      :fq => '(title_ss:Yes OR blog_id_i:1 OR category_ids_im:4)'
     )
   end
 
@@ -301,7 +379,7 @@ describe 'Search' do
       end
     end
     connection.should have_last_search_with(
-      :fq => "(-id:Post\\ #{post.id} OR category_ids_im:1)"
+      :fq => "-(id:Post\\ #{post.id} AND -category_ids_im:1)"
     )
   end
 

data/spec/integration/scoped_search_spec.rb

@@ -153,6 +153,107 @@ describe 'scoped_search' do
     end
   end
 
+  describe 'connectives' do
+    before :each do
+      Sunspot.remove_all
+    end
+
+    it 'should return results that match any restriction in a disjunction' do
+      posts = (1..3).map { |i| Post.new(:blog_id => i)}
+      Sunspot.index!(posts)
+      Sunspot.search(Post) do
+        any_of do
+          with(:blog_id, 1)
+          with(:blog_id, 2)
+        end
+      end.results.should == posts[0..1]
+    end
+
+    it 'should return results that match a nested conjunction in a disjunction' do
+      posts = [
+        Post.new(:title => 'No', :blog_id => 1),
+        Post.new(:title => 'Yes', :blog_id => 2),
+        Post.new(:title => 'Yes', :blog_id => 3),
+        Post.new(:title => 'No', :blog_id => 2)
+      ]
+      Sunspot.index!(posts)
+      Sunspot.search(Post) do
+        any_of do
+          with(:blog_id, 1)
+          all_of do
+            with(:blog_id, 2)
+            with(:title, 'Yes')
+          end
+        end
+      end.results.should == posts[0..1]
+    end
+
+    it 'should return results that match a conjunction with a negated restriction' do
+      posts = [
+        Post.new(:title => 'No', :blog_id => 1),
+        Post.new(:title => 'Yes', :blog_id => 2),
+        Post.new(:title => 'No', :blog_id => 2)
+      ]
+      Sunspot.index!(posts)
+      search = Sunspot.search(Post) do
+        any_of do
+          with(:blog_id, 1)
+          without(:title, 'No')
+        end
+      end
+      search.results.should == posts[0..1]
+    end
+
+    it 'should return results that match a conjunction with a disjunction with a conjunction with a negated restriction' do
+      posts = [
+        Post.new(:title => 'Yes', :ratings_average => 2.0),
+        Post.new(:blog_id => 1, :category_ids => [4], :ratings_average => 2.0),
+        Post.new(:blog_id => 1),
+        Post.new(:blog_id => 2),
+        Post.new(:blog_id => 1, :ratings_average => 2.0)
+      ]
+      Sunspot.index!(posts)
+      search = Sunspot.search(Post) do
+        any_of do
+          with(:title, 'Yes')
+          all_of do
+            with(:blog_id, 1)
+            any_of do
+              with(:category_ids, 4)
+              without(:average_rating, 2.0)
+            end
+          end
+        end
+      end
+      search.results.should == posts[0..2]
+    end
+
+    it 'should return results that match a disjunction with a negated restriction and a nested disjunction in a conjunction with a negated restriction' do
+      posts = [
+        Post.new,
+        Post.new(:title => 'Yes', :blog_id => 1, :category_ids => [4], :ratings_average => 2.0),
+        Post.new(:title => 'Yes', :blog_id => 1),
+        Post.new(:title => 'Yes'),
+        Post.new(:title => 'Yes', :category_ids => [4], :ratings_average => 2.0),
+        Post.new(:title => 'Yes', :blog_id => 1, :ratings_average => 2.0)
+      ]
+      Sunspot.index!(posts)
+      search = Sunspot.search(Post) do
+        any_of do
+          without(:title, 'Yes')
+          all_of do
+            with(:blog_id, 1)
+            any_of do
+              with(:category_ids, 4)
+              without(:average_rating, 2.0)
+            end
+          end
+        end
+      end
+      search.results.should == posts[0..2]
+    end
+  end
+
   describe 'multiple column ordering' do
     before do
       Sunspot.remove_all

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: outoftime-sunspot
 version: !ruby/object:Gem::Version 
-  version: 0.9.2
+  version: 0.9.3
 platform: ruby
 authors: 
 - Mat Brown
@@ -12,7 +12,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-07-23 00:00:00 -07:00
+date: 2009-07-29 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -189,6 +189,7 @@ files:
 - templates/schema.xml.haml
 has_rdoc: true
 homepage: http://github.com/outoftime/sunspot
+licenses: 
 post_install_message: 
 rdoc_options: 
 - --charset=UTF-8
@@ -214,7 +215,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.2.0
+rubygems_version: 1.3.5
 signing_key: 
 specification_version: 3
 summary: Library for expressive, powerful interaction with the Solr search engine