sunspot 0.9.7

data/lib/sunspot/query/connective.rb

@@ -0,0 +1,126 @@
+module Sunspot
+  module Query
+    module Connective #:nodoc:
+      # 
+      # Base class for connectives (conjunctions and disjunctions).
+      #
+      class Abstract < Scope
+        def initialize(setup, negated = false) #:nodoc:
+          @setup, @negated = setup, negated
+          @components = []
+        end
+
+        # 
+        # Connective as solr params.
+        #
+        def to_params #:nodoc:
+          { :fq => to_boolean_phrase }
+        end
+
+        # 
+        # Express the connective as a Lucene boolean phrase.
+        #
+        def to_boolean_phrase #:nodoc:
+          phrase = if @components.length == 1
+            @components.first.to_boolean_phrase
+          else
+            component_phrases = @components.map do |component|
+              component.to_boolean_phrase
+            end
+            "(#{component_phrases.join(" #{connector} ")})"
+          end
+          if negated?
+            "-#{phrase}"
+          else
+            phrase
+          end
+        end
+
+        # 
+        # Add a component to the connective. All components must implement the
+        # #to_boolean_phrase method.
+        #
+        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
+        # can return themselves as a conjunction. Inside a disjunction, however,
+        # a conjunction must explicitly be created.
+        #
+        def add_conjunction
+          @components << conjunction = Conjunction.new(setup)
+          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
+          'AND'
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/query/dynamic_query.rb

@@ -0,0 +1,69 @@
+module Sunspot
+  module Query
+    #
+    # A dynamic query is a proxy object that implements the API of the FieldQuery
+    # class, but wraps a dynamic field factory and thus applies the query
+    # components using dynamic field instances.
+    #--
+    # Dynamic queries do not hold their own state, but rather proxy to the query
+    # that generated them, adding components directly to the owning query's
+    # internal state.
+    #++
+    # DynamicQuery instances are publicly generated by the Query#dynamic_query
+    # factory method.
+    # 
+    class DynamicQuery < FieldQuery
+      def initialize(dynamic_field_factory, query) #:nodoc:
+        @dynamic_field_factory, @query = dynamic_field_factory, query
+      end
+      
+      # 
+      # This has the same effect as calling Query#exclude_instance; it is
+      # included for interface completeness.
+      #
+      def exclude_instance(instance)
+        @query.exclude_instance(instance)
+      end
+
+      # 
+      # This has the same effect as calling Query#exclude_instance; it is
+      # included for interface completeness.
+      #
+      def dynamic_query(field_name)
+        @query.dynamic_query(field_name)
+      end
+
+      # 
+      # Add a Sort to the query
+      #
+      def add_sort(sort) #:nodoc:
+        @query.add_sort(sort)
+      end
+
+      # 
+      # Add a component to the query
+      #
+      def add_component(component) #:nodoc:
+        @query.add_component(component)
+      end
+
+      private
+      
+      #
+      # DynamicFieldFactory implements the part of the Setup interface that we
+      # need, so methods in DynamicQuery's superclasses can rely on it without
+      # knowing what it is.
+      #
+      def setup
+        @dynamic_field_factory
+      end
+      
+      # 
+      # So query facets can be added to the query from within dynamic queries
+      #
+      def query_facets
+        @query.query_facets
+      end
+    end
+  end
+end

data/lib/sunspot/query/field_facet.rb

@@ -0,0 +1,151 @@
+require 'set'
+
+module Sunspot
+  module Query
+    #
+    # Encapsulates a query component representing a field facet. Users create
+    # instances using DSL::Query#facet
+    #
+    class FieldFacet #:nodoc:
+      class <<self
+        protected :new
+
+        # 
+        # Return the appropriate FieldFacet instance for the field and options.
+        # If a :time_range option is specified, and the field type is TimeType,
+        # build a DateFieldFacet. Otherwise, build a normal FieldFacet.
+        #
+        # ==== Returns
+        #
+        # FieldFacet:: FieldFacet instance of appropriate class.
+        #
+        def build(field, options)
+          if options.has_key?(:time_range)
+            unless field.type == Type::TimeType
+              raise(
+                ArgumentError,
+                ":time_range key can only be specified for time fields"
+              )
+            end
+            DateFieldFacet.new(field, options)
+          elsif options.has_key?(:only)
+            QueryFieldFacet.new(field, options.delete(:only))
+          else
+            FieldFacet.new(field, options)
+          end
+        end
+      end
+
+      def initialize(field, options)
+        @field, @options = field, options
+      end
+
+      # ==== Returns
+      #
+      # Hash:: solr-ruby params for this field facet
+      #
+      def to_params
+        params = { :"facet.field" => [@field.indexed_name], :facet => 'true' }
+        params[param_key(:sort)] = 
+          case @options[:sort]
+          when :count then 'true'
+          when :index then 'false'
+          when nil
+          else raise(ArgumentError, 'Allowed facet sort options are :count and :index')
+          end
+        params[param_key(:limit)] = @options[:limit]
+        params[param_key(:mincount)] =
+          if @options[:minimum_count] then @options[:minimum_count]
+          elsif @options[:zeros] then 0
+          else 1
+          end
+        params
+      end
+
+      private
+
+      # 
+      # Given a facet parameter name, return the appropriate Solr parameter for
+      # this facet.
+      #
+      # ==== Returns
+      #
+      # Symbol:: Solr query parameter key
+      #
+      def param_key(name)
+        :"f.#{@field.indexed_name}.facet.#{name}"
+      end
+    end
+
+    class DateFieldFacet < FieldFacet #:nodoc:
+      ALLOWED_OTHER = Set.new(%w(before after between none all))
+
+      # 
+      # Convert the facet to date params.
+      #
+      def to_params
+        super.merge(
+          :"facet.date" => [@field.indexed_name],
+          param_key('date.start') => start_time.utc.xmlschema,
+          param_key('date.end') => end_time.utc.xmlschema,
+          param_key('date.gap') => "+#{interval}SECONDS",
+          param_key('date.other') => others
+        )
+      end
+
+      private
+
+      # 
+      # Start time for facet range
+      #
+      # ==== Returns
+      #
+      # Time:: Start time
+      #
+      def start_time
+        @options[:time_range].first
+      end
+
+      # 
+      # End time for facet range
+      #
+      # ==== Returns
+      #
+      # Time:: End time
+      #
+      def end_time
+        @options[:time_range].last
+      end
+
+      # 
+      # Time interval that each facet row should cover. Default is 1 day.
+      #
+      # ===== Returns
+      #
+      # Integer:: Time interval in seconds
+      #
+      def interval
+        @options[:time_interval] || 86400
+      end
+
+      # 
+      # Other time ranges to create facet rows for. Allowed values are defined
+      # in ALLOWED_OTHER constant.
+      #
+      def others
+        if others = @options[:time_other]
+          Array(others).map do |other|
+            other = other.to_s
+            unless ALLOWED_OTHER.include?(other)
+              raise(
+                ArgumentError,
+                "#{other.inspect} is not a valid argument for :time_other"
+              )
+            end
+            other
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/query/field_query.rb

@@ -0,0 +1,63 @@
+module Sunspot
+  module Query
+    # 
+    # This class acts as a base class for query components that encapsulate
+    # operations on fields. It is subclassed by the Query::Query class and the
+    # Query::DynamicQuery class.
+    #
+    class FieldQuery < Scope
+      # 
+      # Add a field facet. See Sunspot::Facet for more information.
+      #
+      # ==== Parameters
+      #
+      # field_name<Symbol>:: Name of the field on which to get a facet
+      #
+      # ==== Returns
+      #
+      # FieldFacet:: The field facet object
+      #
+      def add_field_facet(field_name, options = nil)
+        options ||= {}
+        facet =
+          if only = options.delete(:only)
+            query_facets[field_name.to_sym] = QueryFieldFacet.new(@setup.field(field_name), only) 
+          else
+            FieldFacet.build(build_field(field_name), options)
+          end
+        add_component(facet)
+      end
+
+      # 
+      # Add a query facet.
+      #
+      # ==== Parameters
+      #
+      # name<Symbol>::
+      #   The name associated with the query facet. This is not passed to Solr,
+      #   but allows the user to retrieve the facet result by passing the name
+      #   to the Search#facet method.
+      #
+      # ==== Returns
+      #
+      # QueryFacet:: The query facet object
+      #
+      def add_query_facet(name)
+        add_component(facet = QueryFacet.new(name, setup))
+        query_facets[name.to_sym] = facet
+      end
+
+      # 
+      # Set result ordering.
+      #
+      # ==== Parameters
+      #
+      # field_name<Symbol>:: Name of the field on which to order
+      # direction<Symbol>:: :asc or :desc (default :asc)
+      #
+      def order_by(field_name, direction = nil)
+        add_sort(Sort.new(build_field(field_name), direction))
+      end
+    end
+  end
+end

data/lib/sunspot/query/pagination.rb

@@ -0,0 +1,39 @@
+module Sunspot
+  module Query
+    # 
+    # A query component that holds information about pagination. Unlike other
+    # query components, this one is mutable, because the query itself holds a
+    # reference to it and updates it if pagination is changed.
+    #
+    class Pagination #:nodoc:
+      attr_reader :page, :per_page
+
+      def initialize(configuration, page = nil, per_page = nil)
+        @configuration = configuration
+        self.page, self.per_page = page, per_page
+      end
+
+      def to_params
+        { :start => start, :rows => rows }
+      end
+
+      def page=(page)
+        @page = page || 1
+      end
+
+      def per_page=(per_page)
+        @per_page = per_page || @configuration.pagination.default_per_page
+      end
+
+      private
+
+      def start
+        (@page - 1) * @per_page
+      end
+
+      def rows
+        @per_page
+      end
+    end
+  end
+end