UnderpantsGnome-sunspot 0.9.1.1

data/lib/sunspot/query/scope.rb

@@ -0,0 +1,165 @@
+module Sunspot
+  module Query
+    # 
+    # The Scope class encapsulates a set of restrictions that scope search
+    # results (as well as query facets rows). This class's API is exposed by
+    # Query::Query and Query::QueryFacetRow.
+    # 
+    class Scope
+      # 
+      # Add a restriction to the query.
+      # 
+      # ==== Parameters
+      #
+      # field_name<Symbol>:: Name of the field to which the restriction applies
+      # restriction_type<Class,Symbol>::
+      #   Subclass of Sunspot::Query::Restriction::Base, or snake_cased name as symbol
+      #   (e.g., +:equal_to+)
+      # value<Object>::
+      #   Value against which the restriction applies (e.g. less_than(2) has a
+      #   value of 2)
+      # negated::
+      #   Whether this restriction should be negated (use add_negated_restriction)
+      #
+      def add_restriction(field_name, restriction_type, value, negated = false)
+        if restriction_type.is_a?(Symbol)
+          restriction_type = Restriction[restriction_type]
+        end
+        add_component(
+          restriction = restriction_type.new(
+            build_field(field_name), value, negated
+          )
+        )
+        restriction
+      end
+
+      # 
+      # Add a negated restriction to the query. The restriction will be taken as
+      # the opposite of its usual meaning (e.g., an :equal_to restriction will
+      # be "not equal to".
+      #
+      # ==== Parameters
+      #
+      # field_name<Symbol>:: Name of the field to which the restriction applies
+      # restriction_type<Class>::
+      #   Subclass of Sunspot::Query::Restriction::Base to instantiate
+      # value<Object>::
+      #   Value against which the restriction applies (e.g. less_than(2) has a
+      #   value of 2)
+      #
+      def add_negated_restriction(field_name, restriction_type, value)
+        add_restriction(field_name, restriction_type, value, true)
+      end
+
+      # 
+      # Add a disjunction to the scope. The disjunction can then take a set of
+      # restrictions, which are combined with OR semantics.
+      #
+      # ==== Returns
+      #
+      # Connective::Disjunction:: New disjunction
+      #
+      def add_disjunction
+        add_component(disjunction = Connective::Disjunction.new(setup))
+        disjunction
+      end
+
+      # 
+      # Add a conjunction to the scope. In most cases, this will simply return
+      # the Scope object itself, since scopes by default combine their
+      # restrictions with OR semantics. The Connective::Disjunction class
+      # overrides this method to return a Connective::Conjunction.
+      #
+      # ==== Returns
+      #
+      # Scope:: Self or another scope with conjunctive semantics.
+      #
+      def add_conjunction
+        self
+      end
+      
+      #
+      # Exclude a particular instance from the search results
+      #
+      # ==== Parameters
+      #
+      # instance<Object>:: instance to exclude from results
+      #
+      def exclude_instance(instance)
+        add_component(Restriction::SameAs.new(instance, true))
+      end
+
+      # 
+      # Generate a DynamicQuery instance for the given base name.
+      # This gives you access to a subset of the Query API but the operations
+      # apply to dynamic fields inside the dynamic field definition specified
+      # by +base_name+.
+      # 
+      # ==== Parameters
+      # 
+      # base_name<Symbol>::
+      #   Base name of the dynamic field definition to use in the dynamic query
+      #   operations
+      #
+      # ==== Returns
+      #
+      # DynamicQuery::
+      #   Instance providing dynamic query functionality for the given field
+      #   definitions.
+      #
+      def dynamic_query(base_name)
+        DynamicQuery.new(setup.dynamic_field_factory(base_name), self)
+      end
+
+      # 
+      # Determine which restriction type to add based on the type of the value.
+      # Used to interpret query conditions passed as a hash, as well as the
+      # short-form DSL::Scope#with method.
+      #
+      # ==== Parameters
+      #
+      # field_name<Symbol>:: Name of the field on which to apply the restriction
+      # value<Object,Array,Range>:: Value to which to apply to the restriction
+      #--
+      # negated<Boolean>:: Whether to negate the restriction.
+      #
+      def add_shorthand_restriction(field_name, value, negated = false) #:nodoc:
+        restriction_type =
+          case value
+          when Range
+            Restriction::Between
+          when Array
+            Restriction::AnyOf
+          else
+            Restriction::EqualTo
+          end
+        add_restriction(field_name, restriction_type, value, negated)
+      end
+
+      # 
+      # Add a negated shorthand restriction. See #add_shorthand_restriction
+      #
+      def add_negated_shorthand_restriction(field_name, value)
+        add_shorthand_restriction(field_name, value, true)
+      end
+
+      private
+
+      # 
+      # Build a field with the given field name. Subclasses may override this
+      # method.
+      #
+      def build_field(field_name)
+        setup.field(field_name)
+      end
+
+      # 
+      # Return a setup object which can return a field object given a name.
+      # Subclasses may override this method.
+      #
+      def setup
+        @setup
+      end
+    end
+  end
+end

data/lib/sunspot/query/sort.rb

@@ -0,0 +1,36 @@
+module Sunspot
+  module Query
+    # 
+    # The Sort class is a query component representing a sort by a given field.
+    # 
+    class Sort #:nodoc:
+      DIRECTIONS = {
+        :asc => 'asc',
+        :ascending => 'asc',
+        :desc => 'desc',
+        :descending => 'desc'
+      }
+
+      def initialize(field, direction = nil)
+        if field.multiple?
+          raise(ArgumentError, "#{field.name} cannot be used for ordering because it is a multiple-value field")
+        end
+        @field, @direction = field, (direction || :asc).to_sym
+      end
+
+      def to_param
+        "#{@field.indexed_name.to_sym} #{direction_for_solr}"
+      end
+
+      private
+
+      def direction_for_solr
+        DIRECTIONS[@direction] || 
+          raise(
+            ArgumentError,
+            "Unknown sort direction #{@direction}. Acceptable input is: #{DIRECTIONS.keys.map { |input| input.inspect } * ', '}"
+        )
+      end
+    end
+  end
+end

data/lib/sunspot/query/sort_composite.rb

@@ -0,0 +1,33 @@
+module Sunspot
+  module Query
+    # 
+    # The SortComposite class encapsulates an ordered collection of Sort
+    # objects. It's necessary to keep this as a separate class as Solr takes
+    # the sort as a single parameter, so adding sorts as regular components
+    # would not merge correctly in the #to_params method.
+    #
+    class SortComposite #:nodoc:
+      def initialize
+        @sorts = []
+      end
+
+      # 
+      # Add a sort to the composite
+      #
+      def <<(sort)
+        @sorts << sort
+      end
+
+      # 
+      # Combine the sorts into a single param by joining them
+      #
+      def to_params
+        unless @sorts.empty?
+          { :sort => @sorts.map { |sort| sort.to_param } * ', ' }
+        else
+          {}
+        end
+      end
+    end
+  end
+end

data/lib/sunspot/query_facet.rb

@@ -0,0 +1,33 @@
+module Sunspot
+  #
+  # QueryFacet instances encapsulate a set of query facet results. Each facet
+  # corresponds to a group of rows defined inside a DSL::FieldQuery#facet block.
+  #
+  class QueryFacet
+    def initialize(outgoing_query_facet, row_data) #:nodoc:
+      @outgoing_query_facet, @row_data = outgoing_query_facet, row_data
+    end
+
+    # 
+    # Get the rows associated with this query facet. Returned rows are always
+    # ordered by count.
+    #
+    # ==== Returns
+    #
+    # Array:: Collection of QueryFacetRow objects, ordered by count
+    #
+    def rows
+      @rows ||=
+        begin
+          rows = []
+          for row in  @outgoing_query_facet.rows
+            row_query = row.to_boolean_phrase
+            if @row_data.has_key?(row_query)
+              rows << QueryFacetRow.new(row.label, @row_data[row_query])
+            end
+          end
+          rows.sort! { |x, y| y.count <=> x.count }
+        end
+    end
+  end
+end

data/lib/sunspot/query_facet_row.rb

@@ -0,0 +1,21 @@
+module Sunspot
+  # 
+  # Objects of this class encapsulate a single query facet row returned for a
+  # query facet.
+  #
+  class QueryFacetRow
+    #
+    # This is the "label" passed into the query facet row when it is defined in
+    # the search.
+    #
+    attr_reader :value
+    # 
+    # Number of documents in the result set that match this facet's scope.
+    #
+    attr_reader :count
+
+    def initialize(value, count) #:nodoc:
+      @value, @count = value, count
+    end
+  end
+end

data/lib/sunspot/schema.rb

@@ -0,0 +1,165 @@
+using_rubygems = false
+begin
+  require 'haml'
+rescue LoadError => e
+  if using_rubygems
+    raise(e)
+  else
+    using_rubygems = true
+    require 'rubygems'
+    retry
+  end
+end
+
+module Sunspot
+  # 
+  # Object that encapsulates schema information for building a Solr schema.xml
+  # file. This class is used by the schema:compile task as well as the
+  # sunspot-configure-solr executable.
+  #
+  class Schema #:nodoc:all
+    FieldType = Struct.new(:name, :class_name, :suffix)
+    FieldVariant = Struct.new(:attribute, :suffix)
+
+    DEFAULT_TOKENIZER = 'solr.StandardTokenizerFactory'
+    DEFAULT_FILTERS = %w(solr.StandardFilterFactory solr.LowerCaseFilterFactory)
+
+    FIELD_TYPES = [
+      FieldType.new('boolean', 'Bool', 'b'),
+      FieldType.new('sfloat', 'SortableFloat', 'f'),
+      FieldType.new('date', 'Date', 'd'),
+      FieldType.new('sint', 'SortableInt', 'i'),
+      FieldType.new('string', 'Str', 's')
+    ]
+
+    FIELD_VARIANTS = [
+      FieldVariant.new('multiValued', 'm'),
+      FieldVariant.new('stored', 's')
+    ]
+
+    attr_reader :tokenizer, :filters
+
+    def initialize
+      @tokenizer = DEFAULT_TOKENIZER
+      @filters = DEFAULT_FILTERS.dup
+    end
+
+    # 
+    # Attribute field types defined in the schema
+    #
+    def types
+      FIELD_TYPES
+    end
+
+    # 
+    # DynamicField instances representing all the available types and variants
+    #
+    def dynamic_fields
+      fields = []
+      for field_variants in variant_combinations
+        for type in FIELD_TYPES
+          fields << DynamicField.new(type, field_variants)
+        end
+      end
+      fields
+    end
+
+    # 
+    # Which tokenizer to use for text fields
+    #
+    def tokenizer=(tokenizer)
+      @tokenizer = 
+        if tokenizer =~ /\./
+          tokenizer
+        else
+          "solr.#{tokenizer}TokenizerFactory"
+        end
+    end
+
+    # 
+    # Add a filter for text field tokenization
+    #
+    def add_filter(filter)
+      @filters <<
+        if filter =~ /\./
+          filter
+        else
+          "solr.#{filter}FilterFactory"
+        end
+    end
+
+    # 
+    # Return an XML representation of this schema using the Haml template
+    #
+    def to_xml
+      template = File.read(
+        File.join(
+          File.dirname(__FILE__),
+          '..',
+          '..',
+          'templates',
+          'schema.xml.haml'
+        )
+      )
+      engine = Haml::Engine.new(template)
+      engine.render(Object.new, :schema => self)
+    end
+
+    private
+
+    #
+    # All of the possible combinations of variants
+    #
+    def variant_combinations
+      combinations = []
+      0.upto(2 ** FIELD_VARIANTS.length - 1) do |b|
+        combinations << combination = []
+        FIELD_VARIANTS.each_with_index do |variant, i|
+          combination << variant if b & 1<<i > 0
+        end
+      end
+      combinations
+    end
+
+    # 
+    # Represents a dynamic field (in the Solr schema sense, not the Sunspot
+    # sense).
+    #
+    class DynamicField
+      def initialize(type, field_variants)
+        @type, @field_variants = type, field_variants
+      end
+
+      # 
+      # Name of the field in the schema
+      #
+      def name
+        variant_suffixes = @field_variants.map { |variant| variant.suffix }.join
+        "*_#{@type.suffix}#{variant_suffixes}"
+      end
+
+      # 
+      # Name of the type as defined in the schema
+      #
+      def type
+        @type.name
+      end
+
+      # 
+      # Implement magic methods to ask if a field is of a particular variant.
+      # Returns "true" if the field is of that variant and "false" otherwise.
+      #
+      def method_missing(name, *args, &block)
+        if name.to_s =~ /\?$/ && args.empty?
+          if @field_variants.any? { |variant| "#{variant.attribute}?" == name.to_s }
+            'true'
+          else
+            'false'
+          end
+        else
+          super(name.to_sym, *args, &block)
+        end
+      end
+    end
+  end
+end