erichummel-sunspot 1.2.1 → 2.0.0.pre.111215

data/.gitignore

@@ -6,7 +6,6 @@ pkg
 .DS_Store
 
 .yardoc
-sunspot.gemspec
 README.rdoc
 .bundle
 Gemfile.lock

data/Gemfile

@@ -1,4 +1,5 @@
 source "http://rubygems.org"
 
-# Specify your gem's dependencies in carrierwave_backgrounder.gemspec
+gem 'sunspot_solr', :path => File.expand_path('../../sunspot_solr', __FILE__)
+
 gemspec

data/History.txt

@@ -1,3 +1,33 @@
+== 2.0.0
+* Adds support for field grouping (Andy Lindeman)
+* Adds support for native geospatial searches and ordering (Eric Tang, Bruno Miranda, Andy Lindeman)
+* Bundled Solr installation (`sunspot_solr`) is version 3.5.0 (Chris Parker)
+* Adds #query_time method to retrieve the Solr query time in
+  milliseconds (Jason Weathered)
+* Fixes syntax of highlighting when used with nested dismax queries (Marco Crepaldi)
+* Adds ability to nest `Sunspot.batch` calls (Thorbjørn Hermansen)
+* Adds `open_timeout` and `read_timeout` configuration options (Rob Di
+  Marco)
+
+== 1.3.0 2011-11-26
+* Requests to Solr use HTTP POST verb by default to avoid issues when the query string grows too large for GET (Johan Van Ryseghem)
+* `sunspot.yml` supports ERB (Andrew Cholakian)
+* An error is raised when attempting to run the packaged Solr if Java is not available (Lucas Parry)
+* Pagination operates correctly without dependency on `will_paginate` (Larry Sprock, Dave Krupinski)
+* Stored boolean fields with `false` value are returned correctly (yipdw)
+* `highlight` accepts `:formatter` and `:fragmenter` parameters (Jeremy McNevin)
+* Default `headerBufferSize` is increased for packaged Solr make sure the limit is not reached during large queries (gjb83)
+* Packaged Solr respects the `data_path` configuration setting from `sunspot.yml` (djmaze)
+* Packaged Solr correctly uses the `pid_dir` configuration option from `sunspot.yml` (Russen Guggemos)
+* Specs run correctly in 1.9.2 (Larry Sprock)
+* Documentation improvements (Thibaut Barrère, gjb83, Breno Santos Salgado)
+* Adds :offset option to paginate method (Benjamin Fleischer)
+* Requires rsolr 1.0.6, which fixes issues with Unicode characters
+  returned by Solr
+
+== 1.2.1 2010-12-28
+* Decreased default reindexing batch size from 500 to 50
+
 == 1.2.0 2010-12-28
 * Replace solr-spatial-light with client-side geohash-based spatial search
 * Override Solr field naming conventions using :as option

data/Rakefile

@@ -1,17 +1,13 @@
-ENV['RUBYOPT'] = '-W1'
-
 # encoding: UTF-8
-require 'bundler'
-Bundler::GemHelper.install_tasks
 
-require 'spec/rake/spectask'
+require 'rspec/core/rake_task'
 
 Dir['tasks/**/*.rake'].each { |t| load t }
 
 desc "Run all examples"
-Spec::Rake::SpecTask.new(:spec) do |t|
-  t.spec_files = Dir.glob('spec/**/*_spec.rb')
-  t.spec_opts << '--format specdoc'
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = '--format documentation'
+  t.ruby_opts  = "-W1"
 end
 
-task :default => 'spec'
+task :default => :spec

data/lib/sunspot.rb

@@ -14,7 +14,7 @@ require File.join(File.dirname(__FILE__), 'light_config')
 
 %w(util adapters configuration setup composite_setup text_field_setup field
    field_factory data_extractor indexer query search session session_proxy
-   type dsl).each do |filename|
+   type dsl class_set).each do |filename|
   require File.join(File.dirname(__FILE__), 'sunspot', filename)
 end
 
@@ -41,9 +41,12 @@ module Sunspot
   IllegalSearchError = Class.new(StandardError)
   NotImplementedError = Class.new(StandardError)
 
-  autoload :Server, File.join(File.dirname(__FILE__), 'sunspot', 'server')
   autoload :Installer, File.join(File.dirname(__FILE__), 'sunspot', 'installer')
 
+  # Array to track classes that have been set up for searching.
+  # Used by, e.g., Sunspot::Rails for reindexing all searchable classes.
+  @searchable = ClassSet.new
+
   class <<self
     # 
     # Clients can inject a session proxy, allowing them to implement custom
@@ -53,6 +56,11 @@ module Sunspot
     #
     attr_writer :session
 
+    #
+    # Access the list of classes set up to be searched.
+    #
+    attr_reader :searchable
+
     # Configures indexing and search for a given class.
     #
     # ==== Parameters
@@ -154,6 +162,7 @@ module Sunspot
     # the dynamic name, which is the part that is specified at indexing time.
     # 
     def setup(clazz, &block)
+      Sunspot.searchable << clazz
       Setup.setup(clazz, &block)
     end
 
@@ -329,7 +338,8 @@ module Sunspot
     #   end
     #
     # See Sunspot::DSL::Search, Sunspot::DSL::Scope, Sunspot::DSL::FieldQuery
-    # and Sunspot::DSL::Query for the full API presented inside the block.
+    # and Sunspot::DSL::StandardQuery for the full API presented inside the
+    # block.
     #
     def search(*types, &block)
       session.search(*types, &block)

data/lib/sunspot/batcher.rb

@@ -0,0 +1,62 @@
+module Sunspot
+  #
+  # Keeps a stack of batches and helps out when Indexer is asked to batch documents.
+  #
+  # If the client does something like 
+  #   
+  #   Sunspot.batch do
+  #     some_code_here
+  #     which_triggers_some_other_code
+  #     which_again_calls
+  #     Sunspot.batch { ... }
+  #   end
+  #
+  # it is the Batcher's job to keep track of these nestings. The inner will
+  # be sent of to be indexed first.
+  #
+  class Batcher
+    include Enumerable
+
+    # Raised if you ask to end current, but no current exists
+    class NoCurrentBatchError < StandardError; end
+
+    def initialize
+      @stack = []
+    end
+
+    def current
+      @stack.last or start_new
+    end
+
+    def start_new
+      (@stack << []).last
+    end
+
+    def end_current
+      fail NoCurrentBatchError if @stack.empty?
+
+      @stack.pop
+    end
+
+    def depth
+      @stack.length
+    end
+
+    def batching?
+      depth > 0
+    end
+
+    def each(&block)
+      current.each(&block)
+    end
+
+    def push(value)
+      current << value
+    end
+    alias << push
+
+    def concat(values)
+      current.concat values
+    end
+  end
+end

data/lib/sunspot/class_set.rb

@@ -0,0 +1,23 @@
+module Sunspot
+  class ClassSet
+    include Enumerable
+
+    def initialize
+      @name_to_klass = {}
+    end
+
+    def <<(klass)
+      @name_to_klass[klass.name.to_sym] = klass
+      self
+    end
+    alias_method :add, :<<
+
+    def each(&block)
+      @name_to_klass.values.each(&block)
+    end
+
+    def empty?
+      @name_to_klass.empty?
+    end
+  end
+end

data/lib/sunspot/configuration.rb

@@ -8,6 +8,8 @@ module Sunspot
   # Sunspot.config.pagination.default_per_page::
   #   Solr always paginates its results. This sets Sunspot's default result
   #   count per page if it is not explicitly specified in the query.
+  # Sunspot.config.indexing.default_batch_size::
+  #   This sets the batch size for indexing, default is 50
   #
   module Configuration
     class <<self
@@ -21,6 +23,8 @@ module Sunspot
         LightConfig.build do
           solr do
             url 'http://127.0.0.1:8983/solr'
+            read_timeout nil
+            open_timeout nil
           end
           master_solr do
             url nil
@@ -28,6 +32,9 @@ module Sunspot
           pagination do
             default_per_page 30
           end
+          indexing do
+            default_batch_size 50
+          end
         end
       end
       

data/lib/sunspot/dsl.rb

@@ -1,5 +1,5 @@
 %w(fields scope paginatable adjustable field_query standard_query query_facet
    functional fulltext restriction restriction_with_near search
-   more_like_this_query function).each do |file|
+   more_like_this_query function field_group).each do |file|
   require File.join(File.dirname(__FILE__), 'dsl', file)
 end

data/lib/sunspot/dsl/field_group.rb

@@ -0,0 +1,57 @@
+module Sunspot
+  module DSL
+    class FieldGroup
+      def initialize(query, setup, group)
+        @query, @setup, @group = query, setup, group
+      end
+
+      #
+      # Sets the number of results (documents) to return for each group.
+      # Defaults to 1.
+      #
+      def limit(num)
+        @group.limit = num
+      end
+
+      #
+      # If set, facet counts are based on the most relevant document of
+      # each group matching the query.
+      #
+      # Supported in Solr 3.4 and above.
+      #
+      # ==== Example
+      #
+      #     Sunspot.search(Post) do
+      #       group :title do
+      #         truncate
+      #       end
+      #
+      #       facet :title, :extra => :any
+      #     end
+      #
+      def truncate
+        @group.truncate = true
+      end
+
+      # Specify the order that results should be returned in. This method can
+      # be called multiple times; precedence will be in the order given.
+      #
+      # ==== Parameters
+      #
+      # field_name<Symbol>:: the field to use for ordering
+      # direction<Symbol>:: :asc or :desc (default :asc)
+      #
+      def order_by(field_name, direction = nil)
+        sort =
+          if special = Sunspot::Query::Sort.special(field_name)
+            special.new(direction)
+          else
+            Sunspot::Query::Sort::FieldSort.new(
+              @setup.field(field_name), direction
+            )
+          end
+        @group.add_sort(sort)
+      end
+    end
+  end
+end

data/lib/sunspot/dsl/field_query.rb

@@ -31,6 +31,27 @@ module Sunspot
         @query.add_sort(sort)
       end
 
+      #
+      # Specify that the results should be ordered based on their
+      # distance from a given point.
+      #
+      # ==== Parameters
+      #
+      # field_name<Symbol>::
+      #   the field that stores the location (declared as `latlon`)
+      # lat<Numeric>::
+      #   the reference latitude
+      # lon<Numeric>::
+      #   the reference longitude
+      # direction<Symbol>::
+      #   :asc or :desc (default :asc)
+      # 
+      def order_by_geodist(field_name, lat, lon, direction = nil)
+        @query.add_sort(
+          Sunspot::Query::Sort::GeodistSort.new(@setup.field(field_name), lat, lon, direction)
+        )
+      end
+
       # 
       # DEPRECATED Use <code>order_by(:random)</code>
       #
@@ -38,6 +59,33 @@ module Sunspot
         order_by(:random)
       end
 
+      # Specify a field for result grouping. Grouping groups documents
+      # with a common field value, return only the top document per
+      # group.
+      #
+      # More information in the Solr documentation:
+      # <http://wiki.apache.org/solr/FieldCollapsing>
+      #
+      # ==== Parameters
+      #
+      # field_name<Symbol>:: the field to use for grouping
+      def group(*field_names, &block)
+        options = Sunspot::Util.extract_options_from(field_names)
+
+        field_names.each do |field_name|
+          field = @setup.field(field_name)
+          group = @query.add_group(Sunspot::Query::FieldGroup.new(field))
+          @search.add_field_group(field)
+
+          if block
+            Sunspot::Util.instance_eval_or_call(
+              FieldGroup.new(@query, @setup, group),
+              &block
+            )
+          end
+        end
+      end
+
       #
       # Request a facet on the search query. A facet is a feature of Solr that
       # determines the number of documents that match the existing search *and*

data/lib/sunspot/dsl/function.rb

@@ -5,7 +5,20 @@ module Sunspot
         @functional = functional
       end
 
+      # Special case to handle <http://wiki.apache.org/solr/FunctionQuery#sub>
+      # because `Kernel#sub` exists so `method_missing` will not be called
+      # for this function.
+      def sub(*args) #:nodoc:
+        create_function_query(:sub, *args)
+      end
+
       def method_missing(method, *args, &block)
+        create_function_query(method, *args)
+      end
+
+      private
+
+      def create_function_query(method, *args)
         function_args = args.map { |arg| @functional.create_function_query(arg) }
         Sunspot::Query::FunctionalFunctionQuery.new(method, function_args)
       end

data/lib/sunspot/dsl/paginatable.rb

@@ -17,11 +17,15 @@ module Sunspot
       #   How many results to return per page. The default is the value in
       #   +Sunspot.config.pagination.default_per_page+
       #
+      # :offset<Integer,String>::
+      #   Applies a shift to paginated records. The default is 0.
+      #
       def paginate(options = {})
         page = options.delete(:page)
         per_page = options.delete(:per_page)
+        offset = options.delete(:offset)
         raise ArgumentError, "unknown argument #{options.keys.first.inspect} passed to paginate" unless options.empty?
-        @query.paginate(page, per_page)
+        @query.paginate(page, per_page, offset)
       end
     end
   end

data/lib/sunspot/dsl/restriction_with_near.rb

@@ -116,6 +116,45 @@ module Sunspot
       def near(lat, lng, options = {})
         @query.fulltext.add_location(@field, lat, lng, options)
       end
+
+      #
+      # Performs a query that is filtered by a radius around a given
+      # latitude and longitude.
+      #
+      # ==== Parameters
+      #
+      # :lat<Numeric>::
+      #   Latitude (in degrees)
+      # :lon<Numeric>::
+      #   Longitude (in degrees)
+      # :radius<Numeric>::
+      #   Radius (in kilometers)
+      #
+      # ==== Options
+      #
+      # <dt><code>:bbox</code></dt>
+      # <dd>If `true`, performs the search using `bbox`. `bbox` is
+      # more performant, but also more inexact (guaranteed to encompass
+      # all of the points of interest, but may also include other points
+      # that are slightly outside of the required distance).</dd>
+      #
+      def in_radius(lat, lon, radius, options = {})
+        @query.add_geo(Sunspot::Query::Geofilt.new(@field, lat, lon, radius, options))
+      end
+
+      #
+      # Performs a query that is filtered by a bounding box
+      #
+      # ==== Parameters
+      # 
+      # :first_corner<Array>::
+      #   First corner (expressed as an array `[latitude, longitude]`)
+      # :second_corner<Array>::
+      #   Second corner (expressed as an array `[latitude, longitude]`)
+      #
+      def in_bounding_box(first_corner, second_corner)
+        @query.add_geo(Sunspot::Query::Bbox.new(@field, first_corner, second_corner))
+      end
     end
   end
 end