gojee-sunspot 2.0.3 → 2.0.4

data/.gitignore

@@ -0,0 +1,12 @@
+sunspot-solr.pid
+*.swp
+coverage
+pkg
+/doc
+.DS_Store
+
+.yardoc
+README.rdoc
+.bundle
+Gemfile.lock
+*un~

data/Gemfile

@@ -0,0 +1,5 @@
+source "http://rubygems.org"
+
+gem 'sunspot_solr', :path => File.expand_path('../../sunspot_solr', __FILE__)
+
+gemspec

data/History.txt

@@ -0,0 +1,252 @@
+== 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
+* Delegate #id method directly to calling context inside DSL
+* Create a SilentFailSessionProxy that rescues exceptions on write operations.
+* Inclusion by identity
+* Solr optimize command
+* Ignore negative :limit option for query facets
+* Eliminated value sorting for range scopes
+* Correctly cast stored boolean values if they are booleans
+* Correctly cast and return stored values for multi-valued fields
+
+== 1.1.0 2010-04-01
+* MoreLikeThis support
+* Allow multiple fulltext queries in one search
+* Function queries
+* Update solr-spatial-light to 0.0.6 build
+* Support for :prefix when faceting.
+* Allow specification of solr jar
+* Updated reindex task to allow setting of batch size and list of models to index
+* Use a '*:*' query for deleting the entire index
+* Ability to specify custom request handler for queries
+* Gracefully handle nonexistent search result
+
+== 1.0.4 2010-03-19
+* Update solr-spatial-light to 0.0.5
+  * Fix NullPointerException in repeated geo search
+  * Fix missing distances in repeated geo search
+* Don't query the data store more than once when results are missing
+
+== 1.0.2 2010-03-11
+* Restore Hit#distance for result geo distance
+* Remove :distance special sort
+* Quote reserved keywords in boolean queries
+* Add Search#facets accessor to retrieve all facets
+
+== 1.0.1 2010-03-05
+* Copy all needed config files when sunspot-installer run with force option
+
+== 1.0.0 2010-03-03
+* Multiselect Field Faceting
+* Named field facets
+* Upgrade to Solr 1.4
+* Deletion by query
+* Allow :latitude and :longitude as coordinate method names
+* Assumed inconsistency
+* Support for TrieField numeric/time types
+* Built-in Session Proxies: Thread-local, master/slave, sharding
+* Give DSL blocks access to calling context
+* Create sunspot-installer executable, which modifies an existing
+	schema/solrconfig to work with Sunspot
+* Support for Long and Double types
+* new_search method accepts DSL block
+* Sunspot::Server now a real class that manages embedded Sunspot instance
+* Add Search#each_hit_with_result method
+* Able to access stored dynamic fields
+* Access dynamic facets using the #facet method
+* Remove accidental existence of dynamic_text fields
+* Upgrade to RSolr 0.12.1
+* Switch from LocalSolr to solr-spatial-light
+* Turn off request logging in Jetty for default Solr install
+* Full support for class-reloading of Sunspot-setup classes
+* Support time ranges outside of 32-bit range
+* Remove sunspot-configure-solr executable
+* new_search method accepts DSL block
+
+== 0.10.8 2009-11-24
+* Strictly enforce RSolr 0.9.6 gem dependency (newer ones broken)
+
+== 0.10.7 2009-11-16
+* Ignore boost_fields that don't apply
+* Ability to specify text_fields inside connectives
+* Fix bug with newlines in strings incorrectly being considered multi-value
+* Compatibility with RSolr 0.10.1
+* Remove commented-out code entirely
+
+== 0.10.6 2009-11-05
+* Support more dismax parameters
+* Support multiple boost queries
+* Allow "extra" facet rows
+* Allow exclusion of fulltext fields
+* Allow specification of per-field highlighting params
+* Specify coordinates using block extraction
+* Return empty array if no highlights available
+* Get stored text fields from hits
+* Update docs to reflect a requirement of at least one search type
+* added --max-memory and --min-memory parameters to sunspot-solr
+* LocalLucene and LocalSolr compatible with Java 1.5
+
+== 0.10.5 2009-10-22
+* Fix highlighting for multiple-model search
+
+== 0.10.4 2009-10-20
+* Add adjust_params method, allowing experts to manually edit Solr params
+* Track adds and deletes separately in session, and expose delete_dirty? method
+* Allow clients to inject a singleton session proxy
+
+== 0.10.3 2009-10-15
+* Contiguous, not continuous
+* Fail fast if less-than-1 radius passed for local search
+
+== 0.10.2 2009-10-09
+* Add Sunspot.config.xml_builder option, which is passed to RSolr
+
+== 0.10.1 2009-10-08
+* Fix directory bugs in sunspot-solr executable
+
+== 0.10.0 2009-10-08
+* Support for geographical search using LocalSolr
+* Support for keyword highlighting, with custom deferred formatting
+* New fulltext DSL for specifying advanced dismax options
+* Support boost queries
+* Support for search-time field boost
+* Support for phrase fields
+* Support for prefix queries
+* Set default search-time field boost in setup
+* Restrict field facet to a set of desired values
+* Query facets support all facet options
+* Allow scoping by text fields
+* Support executing searches repeatedly
+* Allow setting of Solr URL for integration tests in environment variable
+* Add support for master/slave configurations
+* Added logging options to sunspot-solr executable
+* Added default solr config file location to Sunspot::Configuration
+* Informative, non-firehose Search#inspect
+* No longer require arguments to #paginate
+* Silently ignore keyword calls with nil/blank/whitespace keywords
+* Don't require that all searched types have a referenced field
+* Correct backwards ranges
+* Raise descriptive error if no types passed to search
+* Handle empty query facets, query facet rows, and connectives
+* Quote values in range restrictions if they contain spaces
+* Fix bug in Sunspot::Util.full_const_get
+* Remove support for :other option in time faceting
+* Remove order_by_random() method
+* Removed options and Query from public API
+* Use built-in optparse instead of optiflag in bin/sunspot-solr
+* Remove dependency on haml and use erb since it is only used to generate one file
+
+== 0.9.0 2009-07-21
+* Use Dismax parser for keyword search
+* Field and document boosting
+* Specify which fields to search in keyword search
+* Allow indexing of multiple values in text fields
+* Access keyword relevance score in Hit objects
+* Allow stored fields, retrieve stored values from Hit objects
+* Support more values in shorthand restrictions
+* Disjunctions and conjunctions
+* Random ordering
+* Control all options for field facets
+* Time range facets
+* Get referenced objects from facets on foreign keys
+* Facet by class
+* Batch indexing
+* New Date field type
+* Direct access to data accessors
+* Executable to configure production Solr instances
+* Replace solr-ruby with RSolr
+* Remove accidental ActiveSupport dependency
+
+== 0.8.9 2009-06-23
+* Fix OrderedHash bug in older versions of ActiveSupport
+
+== 0.8.8 2009-06-15
+* Escape type names to support namespaced classes
+* Fix bug with anonymous modules in Ruby 1.9
+
+== 0.8.7 2009-06-10
+* Add --pid-dir option for sunspot-solr executable
+
+== 0.8.5 2009-06-09
+* Added dependencies for sunspot-solr executable to gem dependencies
+* Search for adapters using class ancestors rather than superclasses
+
+== 0.8.3 2009-06-03
+* Index objects passed as a collection in a single HTTP request
+
+== 0.8.2 2009-05-27
+* Allow specification of Solr home when using sunspot-solr
+
+== 0.8.1 2009-05-26
+* Add Search#execute! to public API
+
+== 0.8.0 2009-05-22
+* Access query API directly; instantiate search without running it
+* Dynamic fields
+* Search blocks can be evaluated in calling context
+
+== 0.7.3 2009-05-06
+* Better exception handling when class doesn't have adapter/setup
+
+== 0.7.2 2009-04-29
+* Dirty sessions
+
+== 0.7.1 2009-04-29
+* Removed extlib dependency from gemspec
+
+== 0.7.0 2009-04-28
+* Less magic in the DSL
+* Restrict by empty values
+* Negative scoping using without() method
+* Exclusion by object identity using without(instance)
+* Support for faceting
+* Explicit commits
+* Boolean field type
+* Attribute field flexibility
+* Virtual field blocks can be evaluated in calling context
+* Order available by multiple fields
+* New adapter API
+* Got rid of builder API
+* Full documentation
+
+== 0.0.2 2009-02-14
+* Run sunspot's built-in Solr instance using
+  sunspot-solr executable
+* Search hash interpretation delegated to
+  Builder object
+
+== 0.0.1 2008-12-11
+* Initial release
+* Define indexing for any class using DSL
+* Search indexed classes using DSL

data/LICENSE

@@ -0,0 +1,18 @@
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,13 @@
+# encoding: UTF-8
+
+require 'rspec/core/rake_task'
+
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+desc "Run all examples"
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = '--format documentation'
+  t.ruby_opts  = "-W1"
+end
+
+task :default => :spec

data/TODO

@@ -0,0 +1,13 @@
+=== Sunspot 1.1.x ===
+* commitWithin (needs support from RSolr, currently available in master)
+* commit options (non-blocking, etc.)
+
+=== Someday ===
+* Shorthand arguments to Sunspot#search
+* Rudimentary fulltext prefixing support
+
+=== Solr 1.5 ===
+* Field Collapsing (SOLR-236)
+* Support for official spatial support (SOLR-773)
+* Support sorting by function
+* Support string constants in functions

data/lib/light_config.rb

@@ -0,0 +1,40 @@
+module LightConfig
+  class Configuration
+    def initialize(&block)
+      @properties = {}
+      ::LightConfig::Builder.new(self).instance_eval(&block)
+      singleton = (class <<self; self; end)
+      @properties.keys.each do |property|
+        singleton.module_eval do
+          define_method property do
+            @properties[property]
+          end
+
+          define_method "#{property}=" do |value|
+            @properties[property] = value
+          end
+        end
+      end
+    end
+  end
+
+  class Builder
+    def initialize(configuration)
+      @configuration = configuration
+    end
+
+    def method_missing(method, *args, &block)
+      raise ArgumentError("wrong number of arguments(#{args.length} for 1)") unless args.length < 2
+      value = if block then ::LightConfig::Configuration.new(&block)
+              else args.first
+              end
+      @configuration.instance_variable_get(:@properties)[method] = value
+    end
+  end
+
+  class <<self
+    def build(&block)
+      LightConfig::Configuration.new(&block)
+    end
+  end
+end

data/lib/sunspot/adapters.rb

@@ -0,0 +1,265 @@
+module Sunspot
+  # 
+  # Sunspot works by saving references to the primary key (or natural ID) of
+  # each indexed object, and then retrieving the objects from persistent storage
+  # when their IDs are referenced in search results. In order for Sunspot to
+  # know what an object's primary key is, and how to retrieve objects from
+  # persistent storage given a primary key, an adapter must be registered for
+  # that object's class or one of its superclasses (for instance, an adapter
+  # registered for ActiveRecord::Base would be used for all ActiveRecord
+  # models).
+  #
+  # To provide Sunspot with this ability, adapters must have two roles:
+  #
+  # Data accessor::
+  #   A subclass of Sunspot::Adapters::DataAccessor, this object is instantiated
+  #   with a particular class and must respond to the #load() method, which
+  #   returns an object from persistent storage given that object's primary key.
+  #   It can also optionally implement the #load_all() method, which returns
+  #   a collection of objects given a collection of primary keys, if that can be
+  #   done more efficiently than calling #load() on each key.
+  # Instance adapter::
+  #   A subclass of Sunspot::Adapters::InstanceAdapter, this object is
+  #   instantiated with a particular instance. Its only job is to tell Sunspot
+  #   what the object's primary key is, by implementing the #id() method.
+  #
+  # Adapters are registered by registering their two components, telling Sunspot
+  # that they are available for one or more classes, and all of their
+  # subclasses. See Sunspot::Adapters::DataAccessor.register and
+  # Sunspot::Adapters::InstanceAdapter.register for the details.
+  #
+  # See spec/mocks/mock_adapter.rb for an example of how adapter classes should
+  # be implemented.
+  #
+  module Adapters
+    # Subclasses of the InstanceAdapter class should implement the #id method,
+    # which returns the primary key of the instance stored in the @instance
+    # variable. The primary key must be unique within the scope of the
+    # instance's class.
+    #
+    # ==== Example:
+    #
+    #   class FileAdapter < Sunspot::Adapters::InstanceAdapter
+    #     def id
+    #       File.expand_path(@instance.path)
+    #     end
+    #   end
+    #
+    #   # then in your initializer
+    #   Sunspot::Adapters::InstanceAdapter.register(MyAdapter, File)
+    #
+    class InstanceAdapter
+      def initialize(instance) #:nodoc:
+        @instance = instance
+      end
+
+      # 
+      # The universally-unique ID for this instance that will be stored in solr
+      #
+      # ==== Returns
+      #
+      # String:: ID for use in Solr
+      #
+      def index_id #:nodoc:
+        InstanceAdapter.index_id_for(@instance.class.name, id)
+      end
+
+      class <<self
+        # Instantiate an InstanceAdapter for the given object, searching for
+        # registered adapters for the object's class.
+        #
+        # ==== Parameters
+        #
+        # instance<Object>:: The instance to adapt
+        #
+        # ==== Returns
+        #
+        # InstanceAdapter::
+        #   An instance of an InstanceAdapter implementation that
+        #   wraps the given instance
+        #
+        def adapt(instance) #:nodoc:
+          self.for(instance.class).new(instance)
+        end
+
+        # Register an instance adapter for a set of classes. When searching for
+        # an adapter for a given instance, Sunspot starts with the instance's
+        # class, and then searches for registered adapters up the class's
+        # ancestor chain.
+        #
+        # ==== Parameters
+        #
+        # instance_adapter<Class>:: The instance adapter class to register
+        # classes...<Class>::
+        #   One or more classes that this instance adapter adapts
+        #
+        def register(instance_adapter, *classes)
+          classes.each do |clazz|
+            instance_adapters[clazz.name.to_sym] = instance_adapter
+          end
+        end
+
+        # Find the best InstanceAdapter implementation that adapts the given
+        # class.  Starting with the class and then moving up the ancestor chain,
+        # looks for registered InstanceAdapter implementations.
+        #
+        # ==== Parameters
+        #
+        # clazz<Class>:: The class to find an InstanceAdapter for
+        #
+        # ==== Returns
+        #
+        # Class:: Subclass of InstanceAdapter, or nil if none found
+        #
+        # ==== Raises
+        #
+        # Sunspot::NoAdapterError:: If no adapter is registered for this class
+        #
+        def for(clazz) #:nodoc:
+          original_class_name = clazz.name
+          clazz.ancestors.each do |ancestor_class|
+            next if ancestor_class.name.nil? || ancestor_class.name.empty?
+            class_name = ancestor_class.name.to_sym
+            return instance_adapters[class_name] if instance_adapters[class_name]
+          end
+
+          raise(Sunspot::NoAdapterError,
+                "No adapter is configured for #{original_class_name} or its superclasses. See the documentation for Sunspot::Adapters")
+        end
+
+        def index_id_for(class_name, id) #:nodoc:
+          "#{class_name} #{id}"
+        end
+
+        protected
+
+        # Lazy-initialize the hash of registered instance adapters
+        #
+        # ==== Returns
+        #
+        # Hash:: Hash containing class names keyed to instance adapter classes
+        #
+        def instance_adapters #:nodoc:
+          @instance_adapters ||= {}
+        end
+      end
+    end
+
+    # Subclasses of the DataAccessor class take care of retreiving instances of
+    # the adapted class from (usually persistent) storage. Subclasses must
+    # implement the #load method, which takes an id (the value returned by
+    # InstanceAdapter#id, as a string), and returns the instance referenced by
+    # that ID. Optionally, it can also override the #load_all method, which
+    # takes an array of IDs and returns an array of instances in the order
+    # given. #load_all need only be implemented if it can be done more
+    # efficiently than simply iterating over the IDs and calling #load on each
+    # individually.
+    #
+    # ==== Example
+    #
+    #   class FileAccessor < Sunspot::Adapters::InstanceAdapter
+    #     def load(id)
+    #       @clazz.open(id)
+    #     end
+    #   end
+    #
+    #   Sunspot::Adapters::DataAccessor.register(FileAccessor, File)
+    #
+    class DataAccessor
+      def initialize(clazz) #:nodoc:
+        @clazz = clazz
+      end
+
+      # Subclasses can override this class to provide more efficient bulk
+      # loading of instances. Instances must be returned in the same order
+      # that the IDs were given.
+      #
+      # ==== Parameters
+      #
+      # ids<Array>:: collection of IDs
+      #
+      # ==== Returns
+      #
+      # Array:: collection of instances, in order of IDs given
+      #
+      def load_all(ids)
+        ids.map { |id| self.load(id) }
+      end
+
+      class <<self
+        # Create a DataAccessor for the given class, searching registered
+        # adapters for the best match. See InstanceAdapter#adapt for discussion
+        # of inheritence.
+        #
+        # ==== Parameters
+        #
+        # clazz<Class>:: Class to create DataAccessor for
+        #
+        # ==== Returns
+        #
+        # DataAccessor::
+        #   DataAccessor implementation which provides access to given class
+        #
+        def create(clazz) #:nodoc:
+          self.for(clazz).new(clazz)
+        end
+
+        # Register data accessor for a set of classes. When searching for
+        # an accessor for a given class, Sunspot starts with the class,
+        # and then searches for registered adapters up the class's ancestor
+        # chain.
+        #
+        # ==== Parameters
+        #
+        # data_accessor<Class>:: The data accessor class to register
+        # classes...<Class>::
+        #   One or more classes that this data accessor providess access to
+        #
+        def register(data_accessor, *classes)
+          classes.each do |clazz|
+            data_accessors[clazz.name.to_sym] = data_accessor
+          end
+        end
+
+        # Find the best DataAccessor implementation that adapts the given class.
+        # Starting with the class and then moving up the ancestor chain, looks
+        # for registered DataAccessor implementations.
+        #
+        # ==== Parameters
+        #
+        # clazz<Class>:: The class to find a DataAccessor for
+        #
+        # ==== Returns
+        #
+        # Class:: Implementation of DataAccessor
+        #
+        # ==== Raises
+        #
+        # Sunspot::NoAdapterError:: If no data accessor exists for the given class
+        #
+        def for(clazz) #:nodoc:
+          original_class_name = clazz.name
+          clazz.ancestors.each do |ancestor_class|
+            next if ancestor_class.name.nil? || ancestor_class.name.empty?
+            class_name = ancestor_class.name.to_sym
+            return data_accessors[class_name] if data_accessors[class_name]
+          end
+          raise(Sunspot::NoAdapterError,
+                "No data accessor is configured for #{original_class_name} or its superclasses. See the documentation for Sunspot::Adapters")
+        end
+
+        protected
+
+        # Lazy-initialize the hash of registered data accessors
+        #
+        # ==== Returns
+        #
+        # Hash:: Hash containing class names keyed to data accessor classes
+        #
+        def data_accessors #:nodoc:
+          @adapters ||= {}
+        end
+      end
+    end
+  end
+end

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