Add acts_as_solr (excluding internal solr)

Braulio Bhavamitra
1 parent da943ef5
Showing 120 changed files with 7003 additions and 0 deletions Show diff stats
vendor/plugins/acts_as_solr/.gitignore
vendor/plugins/acts_as_solr/CHANGE_LOG
vendor/plugins/acts_as_solr/LICENSE
vendor/plugins/acts_as_solr/README.markdown
vendor/plugins/acts_as_solr/README.rdoc
vendor/plugins/acts_as_solr/Rakefile
vendor/plugins/acts_as_solr/TESTING_THE_PLUGIN
vendor/plugins/acts_as_solr/config/solr.yml
vendor/plugins/acts_as_solr/config/solr_environment.rb
vendor/plugins/acts_as_solr/init.rb
vendor/plugins/acts_as_solr/install.rb
vendor/plugins/acts_as_solr/lib/acts_as_solr.rb
vendor/plugins/acts_as_solr/lib/acts_methods.rb
vendor/plugins/acts_as_solr/lib/class_methods.rb
vendor/plugins/acts_as_solr/lib/common_methods.rb
vendor/plugins/acts_as_solr/lib/deprecation.rb
vendor/plugins/acts_as_solr/lib/instance_methods.rb
vendor/plugins/acts_as_solr/lib/lazy_document.rb
vendor/plugins/acts_as_solr/lib/parser_methods.rb
vendor/plugins/acts_as_solr/lib/search_results.rb
@@ -0,0 +1,8 @@
+*.log
+*.log
+*_pid
+coverage/*
+coverage.data
+solr/solr/data/*
+.svn
+test/db/*.db
@@ -0,0 +1,233 @@
+== CHANGE_LOG
+=== Development
+<b>NEW</b>:: A unit test suite based on Shoulda, not requiring a running Solr or a Rails environment. (Mathias Meyer)
+<b>NEW</b>:: Added the :offline option to the acts_as_solr method. (Mathias Meyer)
+<b>NEW</b>:: Added :lazy flag to find_by_solr, and with that support to load records lazily. (Mathias Meyer)
+<b>FIX</b>:: Added test: to solr.yml so you don't need to do this by hand. (Ken Harris)
+<b>FIX</b>:: Updated bundled Solr to 1.3. (Mathias Meyer)
+<b>FIX</b>:: Updated bundled solr-ruby to 0.0.6 which comes bundled with Solr 1.3. (Mathias Meyer)
+<b>FIX</b>:: Improved logging of the reindex rake task. (David Stevenson)
+<b>FIX</b>:: Added requirement for libxml-ruby > 0.7, if libxml-ruby is installed. (David Stevenson)
+<b>FIX</b>:: Ruby 1.9 compatibility fixes. (David Palm)
+<b>FIX</b>:: Fixed compatibility with Desert by renaming environment.rb to solr_environment.rb. (David Stevenson)
+<b>FIX</b>:: Moved the require of solr_environment only into tasks that need it. (David Stevenson)
+<b>NEW</b>:: Added support to alias fields and includes using the option :as for acts_as_solr. See the RDoc for details. (Nick Hengeveld)
+<b>NEW</b>:: Added support to attach the score to multi search results. (Mathias Meyer)
+<b>NEW</b>:: Added support for facets on date fields. (Curtis Hatter)
+
+=== 06-18-2007: Version 0.9
+<b>NEW</b>:: Added the option :scores when doing a search. If set to true this will return the score as a 'solr_score' attribute or each one of the instances found
+  books = Book.find_by_solr 'ruby OR splinter', :scores => true
+  books.records.first.solr_score
+  => 1.21321397
+  books.records.last.solr_score
+  => 0.12321548
+
+<b>NEW</b>:: Major change on the way the results returned are accessed.
+  books = Book.find_by_solr 'ruby'
+  # the above will return a SearchResults class with 4 methods:
+  # docs|results|records: will return an array of records found
+  # 
+  #   books.records.is_a?(Array)
+  #   => true
+  # 
+  # total|num_found|total_hits: will return the total number of records found
+  # 
+  #   books.total
+  #   => 2
+  # 
+  # facets: will return the facets when doing a faceted search
+  #
+  # max_score|highest_score: returns the highest score found
+  # 
+  #   books.max_score
+  #   => 1.3213213
+
+<b>NEW</b>:: Integrating acts_as_solr to use solr-ruby as the 'backend'. Integration based on the patch submitted by Erik Hatcher
+<b>NEW</b>:: Re-factoring rebuild_solr_index to allow adds to be done in batch; and if a finder block is given, it will be called to retrieve the items to index. (thanks Daniel E.)
+<b>NEW</b>:: Adding the option to specify the port Solr should start when using rake solr:start 
+  rake solr:start RAILS_ENV=your_env PORT=XX
+
+<b>NEW</b>:: Adding deprecation warning for the :background configuration option. It will no longer be updated.
+<b>NEW</b>:: Adding support for models that use a primary key other than integer
+  class Posting < ActiveRecord::Base
+    set_primary_key 'guid' #string
+    #make sure you set the :primary_key_field => 'pk_s' if you wish to use a string field as the primary key
+    acts_as_solr({},{:primary_key_field => 'pk_s'})
+  end
+
+<b>FIX</b>:: Disabling of storing most fields. Storage isn't useful for acts_as_solr in any field other than the pk and id fields. It just takes up space and time. (thanks Daniel E.)
+<b>FIX</b>:: Re-factoring code submitted by Daniel E.
+<b>NEW</b>:: Adding an :auto_commit option that will only send the commit command to Solr if it is set to true
+  class Author < ActiveRecord::Base
+	acts_as_solr :auto_commit => false
+  end
+
+<b>FIX</b>:: Fixing bug on rake's test task
+<b>FIX</b>:: Making acts_as_solr's Post class compatible with Solr 1.2 (thanks Si)
+<b>NEW</b>:: Adding Solr 1.2
+<b>FIX</b>:: Removing Solr 1.1
+<b>NEW</b>:: Adding a conditional :if option to the acts_as_solr call. It behaves the same way ActiveRecord's :if argument option does. 
+  class Electronic < ActiveRecord::Base
+    acts_as_solr :if => proc{|record| record.is_active?}
+  end
+
+<b>NEW</b>:: Adding fixtures to Solr index when using rake db:fixtures:load
+<b>FIX</b>:: Fixing boost warning messages
+<b>FIX</b>:: Fixing bug when adding a facet to a field that contains boost
+<b>NEW</b>:: Deprecating find_with_facet and combining functionality with find_by_solr
+<b>NEW</b>:: Adding the option to :exclude_fields when indexing a model
+  class User < ActiveRecord::Base
+    acts_as_solr :exclude_fields => [:password, :login, :credit_card_number]
+  end
+
+<b>FIX</b>:: Fixing branch bug on older ruby version
+<b>NEW</b>:: Adding boost support for fields and documents being indexed:
+  class Electronic < ActiveRecord::Base
+    # You can add boosting on a per-field basis or on the entire document
+    acts_as_solr :fields => [{:price => {:boost => 5.0}}], :boost => 5.0
+  end
+
+<b>FIX</b>:: Fixed the acts_as_solr limitation to only accept test|development|production environments. 
+
+=== 05-16-2007: Version 0.8.5
+<b>FIX</b>:: There's no need to specify the :field_types anymore when doing a search in a model that specifies a field type for a field.
+<b>FIX</b>:: Better handling of nil values from indexed fields. Solr complained when indexing fields with field type and the field values being passed as nils.
+<b>NEW</b>:: Adding Solr sort (order by) option to the search query (thanks Kevin Hunt)
+<b>FIX</b>:: Applying patch suggested for increasing the Solr commit speed (thanks Mourad Hammiche)
+<b>FIX</b>:: Updated documentation
+
+=== 05-10-2007: Version 0.8
+<b>NEW</b>: New video tutorial
+<b>NEW</b>: Faceted search has been implemented and its possible to 'drill-down' on the facets
+<b>NEW</b>: New rake tasks you can use to start/stop the solr server in test, development and production environments: (thanks Matt Clark)
+  rake solr:start|stop RAILS_ENV=test|development|production (defaults to development if none given)
+
+<b>NEW</b>: Changes to the plugin's test framework and it now supports Sqlite as well (thanks Matt Clark)
+<b>FIX</b>: Patch applied (thanks Micah) that allows one to have multiple solr instances in the same servlet
+<b>FIX</b>: Patch applied (thanks Micah) that allows indexing of STIs
+<b>FIX</b>: Patch applied (thanks Gordon) that allows the plugin to use a table's primary key different than 'id'
+<b>FIX</b>: Returning empty array instead of empty strings when no records are found
+<b>FIX</b>: Problem with unit tests failing due to order of the tests and speed of the commits
+
+=== 02-16-2007: Version 0.7
+<b>NEW</b>: You can now specify the field types when indexing and searching if 
+you'd like to preserve its original type:
+
+<b>Indexing</b>
+
+Each field passed can also be a hash with the value being a field type
+
+ class Electronic < ActiveRecord::Base
+   acts_as_solr :fields => [{:price => :range_float}, {:current_time => :date}]
+   def current_time
+     Time.now
+   end
+ end
+
+<b>Searching</b>
+ Electronic.find_by_solr "ipod AND price:[* TO 59.99]", 
+                         :field_types => [{:price => :range_float}]
+
+The field types accepted are:
+<em>:float</em>:: Index the field value as a float (ie.: 12.87)
+<em>:integer</em>:: Index the field value as an integer (ie.: 31)
+<em>:boolean</em>:: Index the field value as a boolean (ie.: true/false)
+<em>:date</em>:: Index the field value as a date (ie.: Wed Nov 15 23:13:03 PST 2006)
+<em>:string</em>:: Index the field value as a text string, not applying the same indexing filters as a regular text field
+<em>:range_integer</em>:: Index the field value for integer range queries (ie.:[5 TO 20])
+<em>:range_float</em>:: Index the field value for float range queries (ie.:[14.56 TO 19.99])
+
+<b>Setting the field type preserves its original type when indexed</b>
+
+<b>FIX</b>: Fixing sorting bug. Thanks for the catch Laurel
+
+<b>FIX</b>: Fixing small bug when installing the plugin
+
+<b>NEW</b>: Adding the :additional_fields option to the acts_as_solr method
+
+=== 02-05-2007: Version 0.6.5
+<b>NEW</b>:: Added multi-model search, which can be used to execute a search across multiple models:
+  Book.multi_solr_search "Napoleon OR Tom", :models => [Movie]
+
+====options:
+Accepts the same options as find_by_solr plus:
+models:: The additional models you'd like to include in the search
+results_format:: Specify the format of the results found
+                 :objects :: Will return an array with the results being objects (default). Example:
+                              Book.multi_solr_search "Napoleon OR Tom", :models => [Movie], :results_format => :objects
+                 :ids :: Will return an array with the ids of each entry found. Example:
+                          Book.multi_solr_search "Napoleon OR Tom", :models => [Movie], :results_format => :ids
+                          => [{"id" => "Movie:1"},{"id" => Book:1}]
+                         Where the value of each array is as Model:instance_id
+
+=== 02-03-2007: Version 0.6
+<b>NEW</b>:: Added basic faceted search functionality for indexing and searching:
+
+==== Indexing:
+
+ class Electronic < ActiveRecord::Base
+   acts_as_solr :facets => [:category, :manufacturer]  
+ end
+
+==== Searching:
+
+ Electronic.find_with_facet "memory", :facets => {:fields =>[:category]}
+
+=== 01-15-2007: Version 0.5
+<b>NEW</b>:: Added model association indexing, which means you can include any :has_one, :has_many, 
+:belongs_to and :has_and_belongs_to_many association to be indexed:
+
+ class Category < ActiveRecord::Base
+   has_many :books
+   acts_as_solr :include => [:books]
+ end
+
+ class Book < ActiveRecord::Base
+   belongs_to :category
+   acts_as_solr :include => [:category]
+ end
+
+=== 01-11-2007:
+<b>NEW</b>:: Added the acts_as_solr's plugin tests
+
+=== 11-07-2006: Version 0.4
+<b>NEW</b>:: Added :background option, which takes and integer value (in minutes) to wait before committing the changes to Solr. This depends on rail_cron being installed.  By setting up the background job we prevent the users from having to wait for Solr records to be created, and we keep from updating the index over and over for quickly successive changes. (Rob Kaufman)
+
+=== 11-02-2006: Version 0.3
+<b>NEW</b>:: Added a method (Model.count_by_solr) that returns the total number of documents found based on query passed
+<b>NEW</b>:: Added configuration for production and development environments
+
+=== 10-21-2006: Version 0.2
+<b>PLUGIN</b>
+<b>FIX</b>:: Fixed bug when mixing search-by-field and 'free' search: Model.find_by_solr 'solr AND name:Thiago'
+<b>FIX</b>:: Fixed bug with multi-terms search: Book.find_by_solr 'anteater john'
+<b>FIX</b>:: Fixed bug when including more than one search field: Model.find_by_solr 'name:Thiago AND engine:Solr'
+<b>FIX</b>:: Fixed bug when rebuilding the index, it wasn't saving the data
+<b>NEW</b>:: Added the ability to index custom methods from a model as search fields
+<b>NEW</b>:: Added a search method (Model.find_id_by_solr) that will return only the id of the results
+
+<b>SCHEMA.XML</b>
+<b>NEW</b>:: Added a new field: <field name="default" type="text" indexed="true" stored="true" /> 
+<b>NEW</b>:: Added a default search field: <defaultSearchField>default</defaultSearchField>
+<b>FIX</b>:: Changed the defaultOperator to AND instead of OR
+
+=== 09-29-2006: Version 0.1
+<b>PLUGIN</b>
+<b>NEW</b>:: Included the option of having a Solr config file inside the rails env.
+<b>NEW</b>:: Added the ability of indexing only certain fields, if you chose to.
+<b>NEW</b>:: Added configuration options
+<b>NEW</b>:: Changed the way the search was done:
+  	  Old: You were forced the specify the field you wanted to look for 
+      	('field:value') and you had to specify a default search field as 
+       	well, for when you didn't include the 'field' in the search term
+  	  New: The new search features include: 
+        - You don't have to specify a default search field; 
+        - You are not forced to include the field name in the search term, 
+          unless you choose to search for a specific field ('name:Thiago');
+        - You can pass the starting row and the number of rows per page,
+          which is usefull for pagination
+<b>NEW</b>:: Included a method to rebuild the index files
+
+<b>SCHEMA.XML</b>
+<b>NEW</b>:: Created an optimized version of the config file to better work with this plugin
 \ No newline at end of file
@@ -0,0 +1,19 @@
+Copyright (c) 2006 Erik Hatcher, Thiago Jackiw
+
+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.
 \ No newline at end of file
@@ -0,0 +1,94 @@
+`acts_as_solr` Rails plugin
+======
+This plugin adds full text search capabilities and many other nifty features from Apache's [Solr](http://lucene.apache.org/solr/) to any Rails model.
+It was based on the first draft by Erik Hatcher.
+
+Current Release
+======
+The current stable release is v0.9 and was released on 06-18-2007.
+
+Changes
+======
+Please refer to the CHANGE_LOG
+
+Installation
+======
+
+For Rails >= 2.1:
+
+    script/plugin install git://github.com/mattmatt/acts_as_solr.git
+
+For Rails < 2.1:
+
+    cd vendor/plugins
+    git clone git://github.com/mattmatt/acts_as_solr.git
+    rm -rf acts_as_solr/.git
+
+Make sure you copy `vendor/plugins/acts_as_solr/config/solr.yml` to your Rails
+application's config directory, when you install via `git clone`.
+
+Requirements
+------
+* Java Runtime Environment(JRE) 1.5 aka 5.0 [http://www.java.com/en/download/index.jsp](http://www.java.com/en/download/index.jsp)
+* If you have libxml-ruby installed, make sure it's at least version 0.7
+
+Configuration
+======
+Basically everything is configured to work out of the box. You can use `rake solr:start` and `rake solr:stop`
+to start and stop the Solr web server (an embedded Jetty). If the default JVM options aren't suitable for
+your environment, you can configure them in solr.yml with the option `jvm_options`. There is a default
+set for the production environment to have some more memory available for the JVM than the defaults, but
+feel free to change them to your liking.
+
+Basic Usage
+======
+<pre><code>
+# Just include the line below to any of your ActiveRecord models:
+  acts_as_solr
+
+# Or if you want, you can specify only the fields that should be indexed:
+  acts_as_solr :fields => [:name, :author]
+
+# Then to find instances of your model, just do:
+  Model.find_by_solr(query) #query is a string representing your query
+
+# Please see ActsAsSolr::ActsMethods for a complete info
+
+</code></pre>
+
+
+`acts_as_solr` in your tests
+======
+To test code that uses `acts_as_solr` you must start a Solr server for the test environment. You can do that with `rake solr:start RAILS_ENV=test`
+
+However, if you would like to mock out Solr calls so that a Solr server is not needed (and your tests will run much faster), just add this to your `test_helper.rb` or similar:
+
+<pre><code>
+class ActsAsSolr::Post
+  def self.execute(request)
+    true
+  end
+end
+</pre></code>
+
+([via](http://www.subelsky.com/2007/10/actsassolr-capistranhttpwwwbloggercomim.html#c1646308013209805416))
+
+Authors
+======
+Erik Hatcher: First draft<br>
+Thiago Jackiw: Previous developer<br>
+Luke Francl: Current developer<br>
+Mathias Meyer: Current developer<br>
+
+Support
+=======
+
+Check the [project website](http://mattmatt.github.com/acts_as_solr) or stop by the [Google Group](http://groups.google.com/group/acts_as_solr). Send bug reports through [GitHub Issues](http://github.com/mattmatt/acts_as_solr/issues).
+
+Release Information
+======
+Released under the MIT license.
+
+More info
+======
+The old [acts_as_solr homepage](http://acts-as-solr.railsfreaks.com) is no more. For more up-to-date information, check out the project page of the current mainline on [GitHub](http://github.com/mattmatt/acts_as_solr/wikis).
 \ No newline at end of file
@@ -0,0 +1,84 @@
+= acts_as_solr Rails plugin
+
+This plugin adds full text search capabilities and many other nifty features from Apache's Solr[http://lucene.apache.org/solr/] to any Rails model.
+It was based on the first draft by Erik Hatcher.
+
+== Current Release
+
+There is no numbered release yet, but the master branch is always considered stable.
+
+== Support
+
+Check the project website[http://mattmatt.github.com/acts_as_solr] or stop by the Google Group[http://groups.google.com/group/acts_as_solr]. Send bug reports through GitHub[http://github.com/mattmatt/acts_as_solr/issues].
+
+== Changes
+
+Please refer to the CHANGELOG[http://github.com/mattmatt/acts_as_solr/blob/master/CHANGE_LOG]
+
+== Installation
+
+For Rails >= 2.1:
+
+     script/plugin install git://github.com/mattmatt/acts_as_solr.git
+
+For Rails < 2.1:
+
+     cd vendor/plugins
+     git clone git://github.com/mattmatt/acts_as_solr.git
+     rm -rf acts_as_solr/.git
+
+Make sure you copy vendor/plugins/acts_as_solr/config/solr.yml to your Rails
+application's config directory, when you install via git clone.
+
+== Requirements
+
+* Java Runtime Environment(JRE) 1.5 aka 5.0 [http://www.java.com/en/download/index.jsp](http://www.java.com/en/download/index.jsp)
+* If you have libxml-ruby installed, make sure it's at least version 0.7
+
+== Configuration
+
+Basically everything is configured to work out of the box. You can use `rake solr:start` and `rake solr:stop`
+to start and stop the Solr web server (an embedded Jetty). If the default JVM options aren't suitable for
+your environment, you can configure them in solr.yml with the option `jvm_options`. There is a default
+set for the production environment to have some more memory available for the JVM than the defaults, but
+feel free to change them to your liking.
+
+== Basic Usage
+
+# Just include the line below to any of your ActiveRecord models:
+  acts_as_solr
+
+# Or if you want, you can specify only the fields that should be indexed:
+  acts_as_solr :fields => [:name, :author]
+
+# Then to find instances of your model, just do:
+  Model.find_by_solr(query) #query is a string representing your query
+
+# Please see ActsAsSolr::ActsMethods for a complete info
+
+== acts_as_solr in your tests
+
+To test code that uses acts_as_solr you must start a Solr server for the test environment. You can do that with 
+
+    rake solr:start RAILS_ENV=test
+
+However, if you would like to mock out Solr calls so that a Solr server is not needed (and your tests will run much faster), just add this to your `test_helper.rb` or similar:
+
+    class ActsAsSolr::Post
+      def self.execute(request)
+        true
+      end
+    end
+
+(via[http://www.subelsky.com/2007/10/actsassolr-capistranhttpwwwbloggercomim.html#c1646308013209805416])
+
+== Authors
+
+Erik Hatcher: First draft
+Thiago Jackiw: Previous developer
+Luke Francl: Current developer
+Mathias Meyer: Current developer
+
+== Release Information
+
+Released under the MIT license.
 \ No newline at end of file
@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+
+Dir["#{File.dirname(__FILE__)}/lib/tasks/**/*.rake"].sort.each { |ext| load ext }
+
+desc "Default Task"
+task :default => [:test]
+
+desc "Runs the unit tests"
+task :test => "test:unit"
+
+namespace :test do
+  task :setup do
+    ENV['RAILS_ENV'] = "test"
+    require File.dirname(__FILE__) + '/config/solr_environment'
+    puts "Using " + DB
+    %x(mysql -u#{MYSQL_USER} < #{File.dirname(__FILE__) + "/test/fixtures/db_definitions/mysql.sql"}) if DB == 'mysql'
+
+    Rake::Task["test:migrate"].invoke
+  end
+  
+  desc 'Measures test coverage using rcov'
+  task :rcov => :setup do
+    rm_f "coverage"
+    rm_f "coverage.data"
+    rcov = "rcov --rails --aggregate coverage.data --text-summary -Ilib"
+    
+    system("#{rcov} --html #{Dir.glob('test/**/*_test.rb').join(' ')}")
+    system("open coverage/index.html") if PLATFORM['darwin']
+  end
+  
+  desc 'Runs the functional tests, testing integration with Solr'
+  Rake::TestTask.new('functional' => :setup) do |t|
+    t.pattern = "test/functional/*_test.rb"
+    t.verbose = true
+  end
+  
+  desc "Unit tests"
+  Rake::TestTask.new(:unit) do |t|
+    t.libs << 'test/unit'
+    t.pattern = "test/unit/*_shoulda.rb"
+    t.verbose = true
+  end
+end
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_dir = "rdoc"
+  rd.rdoc_files.exclude("lib/solr/**/*.rb", "lib/solr.rb")
+  rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")
+end
 \ No newline at end of file
@@ -0,0 +1,25 @@
+acts_as_solr comes with a quick and fast unit test suite, and with a longer-running
+functional test suite, the latter testing the actual integration with Solr.
+
+The unit test suite is written using Shoulda, so make sure you have a recent version
+installed.
+
+Running `rake test` or just `rake` will run both test suites. Use `rake test:unit` to
+just run the unit test suite.
+ 
+== How to run functional tests for this plugin:
+To run the acts_as_solr's plugin tests run the following steps:
+
+- create a MySQL database called "actsassolr_test" (if you want to use MySQL)
+
+- create a new Rails project, if needed (the plugin can only be tested from within a Rails project); move/checkout acts_as_solr into its vendor/plugins/, as usual
+
+- copy vendor/plugins/acts_as_solr/config/solr.yml to config/ (the Rails config folder)
+
+- rake solr:start RAILS_ENV=test
+
+- rake test:functional (Accepts the following arguments: DB=sqlite|mysql and MYSQL_USER=user)
+
+== Troubleshooting:
+If for some reason the tests don't run and you get MySQL errors, make sure you edit the MYSQL_USER entry under
+config/environment.rb. It's recommended to create or use a MySQL user with no password.
@@ -0,0 +1,15 @@
+# Config file for the acts_as_solr plugin.
+#
+# If you change the host or port number here, make sure you update 
+# them in your Solr config file
+
+development:
+  url: http://127.0.0.1:8982/solr
+  
+production:
+  url: http://127.0.0.1:8983/solr
+  jvm_options: -server -d64 -Xmx1024M -Xms64M
+
+test:
+  url: http://127.0.0.1:8981/solr
+
@@ -0,0 +1,22 @@
+ENV['RAILS_ENV']  = (ENV['RAILS_ENV'] || 'development').dup
+# RAILS_ROOT isn't defined yet, so figure it out.
+rails_root_dir = "#{File.dirname(File.expand_path(__FILE__))}/../../../../"
+SOLR_PATH = "#{File.dirname(File.expand_path(__FILE__))}/../solr" unless defined? SOLR_PATH
+
+SOLR_LOGS_PATH = "#{rails_root_dir}/log" unless defined? SOLR_LOGS_PATH
+SOLR_PIDS_PATH = "#{rails_root_dir}/tmp/pids" unless defined? SOLR_PIDS_PATH
+SOLR_DATA_PATH = "#{rails_root_dir}/solr/#{ENV['RAILS_ENV']}" unless defined? SOLR_DATA_PATH
+
+unless defined? SOLR_PORT
+  config = YAML::load_file(rails_root_dir+'/config/solr.yml')
+  
+  SOLR_PORT = ENV['PORT'] || URI.parse(config[ENV['RAILS_ENV']]['url']).port
+end
+
+SOLR_JVM_OPTIONS = config[ENV['RAILS_ENV']]['jvm_options'] unless defined? SOLR_JVM_OPTIONS
+
+if ENV['RAILS_ENV'] == 'test'
+  DB = (ENV['DB'] ? ENV['DB'] : 'mysql') unless defined?(DB)
+  MYSQL_USER = (ENV['MYSQL_USER'].nil? ? 'root' : ENV['MYSQL_USER']) unless defined? MYSQL_USER
+  require File.join(File.dirname(File.expand_path(__FILE__)), '..', 'test', 'db', 'connections', DB, 'connection.rb')
+end
@@ -0,0 +1,21 @@
+# Copyright (c) 2006 Erik Hatcher, Thiago Jackiw
+# 
+# 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.
+
+require 'acts_as_solr'
 \ No newline at end of file
@@ -0,0 +1,11 @@
+require 'fileutils'
+
+def install(file)
+  puts "Installing: #{file}"
+  target = File.join(File.dirname(__FILE__), '..', '..', '..', file)
+  FileUtils.cp File.join(File.dirname(__FILE__), file), target
+  dir_to_rename = File.dirname(__FILE__) + '/../trunk'
+  FileUtils.mv(dir_to_rename, File.dirname(__FILE__) + '/../acts_as_solr') if File.exists? dir_to_rename
+end
+
+install File.join( 'config', 'solr.yml' )
@@ -0,0 +1,59 @@
+# Copyright (c) 2006 Erik Hatcher, Thiago Jackiw
+#
+# 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.
+
+require 'active_record'
+require 'rexml/document'
+require 'net/http'
+require 'yaml'
+
+require File.dirname(__FILE__) + '/solr'
+require File.dirname(__FILE__) + '/acts_methods'
+require File.dirname(__FILE__) + '/class_methods'
+require File.dirname(__FILE__) + '/instance_methods'
+require File.dirname(__FILE__) + '/common_methods'
+require File.dirname(__FILE__) + '/deprecation'
+require File.dirname(__FILE__) + '/search_results'
+require File.dirname(__FILE__) + '/lazy_document'
+module ActsAsSolr
+  
+  class Post    
+    def self.execute(request)
+      begin
+        if File.exists?(RAILS_ROOT+'/config/solr.yml')
+          config = YAML::load_file(RAILS_ROOT+'/config/solr.yml')
+          url = config[RAILS_ENV]['url']
+          # for backwards compatibility
+          url ||= "http://#{config[RAILS_ENV]['host']}:#{config[RAILS_ENV]['port']}/#{config[RAILS_ENV]['servlet_path']}"
+        else
+          url = 'http://localhost:8982/solr'
+        end
+        connection = Solr::Connection.new(url)
+        return connection.send(request)
+      rescue 
+        raise "Couldn't connect to the Solr server at #{url}. #{$!}"
+        false
+      end
+    end
+  end
+  
+end
+
+# reopen ActiveRecord and include the acts_as_solr method
+ActiveRecord::Base.extend ActsAsSolr::ActsMethods
@@ -0,0 +1,279 @@
+module ActsAsSolr #:nodoc:
+  
+  module ActsMethods
+    
+    # declares a class as solr-searchable
+    # 
+    # ==== options:
+    # fields:: This option can be used to specify only the fields you'd
+    #          like to index. If not given, all the attributes from the 
+    #          class will be indexed. You can also use this option to 
+    #          include methods that should be indexed as fields
+    # 
+    #           class Movie < ActiveRecord::Base
+    #             acts_as_solr :fields => [:name, :description, :current_time]
+    #             def current_time
+    #               Time.now.to_s
+    #             end
+    #           end
+    #          
+    #          Each field passed can also be a hash with the value being a field type
+    # 
+    #           class Electronic < ActiveRecord::Base
+    #             acts_as_solr :fields => [{:price => :range_float}]
+    #             def current_time
+    #               Time.now
+    #             end
+    #           end
+    # 
+    #          The field types accepted are:
+    # 
+    #          :float:: Index the field value as a float (ie.: 12.87)
+    #          :integer:: Index the field value as an integer (ie.: 31)
+    #          :boolean:: Index the field value as a boolean (ie.: true/false)
+    #          :date:: Index the field value as a date (ie.: Wed Nov 15 23:13:03 PST 2006)
+    #          :string:: Index the field value as a text string, not applying the same indexing
+    #                    filters as a regular text field
+    #          :range_integer:: Index the field value for integer range queries (ie.:[5 TO 20])
+    #          :range_float:: Index the field value for float range queries (ie.:[14.56 TO 19.99])
+    # 
+    #          Setting the field type preserves its original type when indexed
+    # 
+    #          The field may also be passed with a hash value containing options
+    #
+    #          class Author < ActiveRecord::Base
+    #            acts_as_solr :fields => [{:full_name => {:type => :text, :as => :name}}]
+    #            def full_name
+    #              self.first_name + ' ' + self.last_name
+    #            end
+    #          end
+    #
+    #          The options accepted are:
+    #
+    #          :type:: Index the field using the specified type
+    #          :as:: Index the field using the specified field name
+    #
+    # additional_fields:: This option takes fields to be include in the index
+    #                     in addition to those derived from the database. You
+    #                     can also use this option to include custom fields 
+    #                     derived from methods you define. This option will be
+    #                     ignored if the :fields option is given. It also accepts
+    #                     the same field types as the option above
+    # 
+    #                      class Movie < ActiveRecord::Base
+    #                       acts_as_solr :additional_fields => [:current_time]
+    #                       def current_time
+    #                         Time.now.to_s
+    #                       end
+    #                      end
+    # 
+    # exclude_fields:: This option taks an array of fields that should be ignored from indexing:
+    # 
+    #                    class User < ActiveRecord::Base
+    #                      acts_as_solr :exclude_fields => [:password, :login, :credit_card_number]
+    #                    end
+    # 
+    # include:: This option can be used for association indexing, which 
+    #           means you can include any :has_one, :has_many, :belongs_to 
+    #           and :has_and_belongs_to_many association to be indexed:
+    # 
+    #            class Category < ActiveRecord::Base
+    #              has_many :books
+    #              acts_as_solr :include => [:books]
+    #            end
+    # 
+    #           Each association may also be specified as a hash with an option hash as a value
+    #
+    #           class Book < ActiveRecord::Base
+    #             belongs_to :author
+    #             has_many :distribution_companies
+    #             has_many :copyright_dates
+    #             has_many :media_types
+    #             acts_as_solr(
+    #               :fields => [:name, :description],
+    #               :include => [
+    #                 {:author => {:using => :fullname, :as => :name}},
+    #                 {:media_types => {:using => lambda{|media| type_lookup(media.id)}}}
+    #                 {:distribution_companies => {:as => :distributor, :multivalued => true}},
+    #                 {:copyright_dates => {:as => :copyright, :type => :date}}
+    #               ]
+    #             ]
+    #
+    #           The options accepted are:
+    #
+    #           :type:: Index the associated objects using the specified type
+    #           :as:: Index the associated objects using the specified field name
+    #           :using:: Index the associated objects using the value returned by the specified method or proc.  If a method
+    #                    symbol is supplied, it will be sent to each object to look up the value to index; if a proc is
+    #                    supplied, it will be called once for each object with the object as the only argument
+    #           :multivalued:: Index the associated objects using one field for each object rather than joining them
+    #                          all into a single field
+    #
+    # facets:: This option can be used to specify the fields you'd like to
+    #          index as facet fields
+    # 
+    #           class Electronic < ActiveRecord::Base
+    #             acts_as_solr :facets => [:category, :manufacturer]  
+    #           end
+    # 
+    # boost:: You can pass a boost (float) value that will be used to boost the document and/or a field. To specify a more
+    #         boost for the document, you can either pass a block or a symbol. The block will be called with the record
+    #         as an argument, a symbol will result in the according method being called:
+    # 
+    #           class Electronic < ActiveRecord::Base
+    #             acts_as_solr :fields => [{:price => {:boost => 5.0}}], :boost => 10.0
+    #           end
+    # 
+    #           class Electronic < ActiveRecord::Base
+    #             acts_as_solr :fields => [{:price => {:boost => 5.0}}], :boost => proc {|record| record.id + 120*37}
+    #           end
+    #
+    #           class Electronic < ActiveRecord::Base
+    #             acts_as_solr :fields => [{:price => {:boost => :price_rating}}], :boost => 10.0
+    #           end
+    #
+    # if:: Only indexes the record if the condition evaluated is true. The argument has to be 
+    #      either a symbol, string (to be eval'ed), proc/method, or class implementing a static 
+    #      validation method. It behaves the same way as ActiveRecord's :if option.
+    # 
+    #        class Electronic < ActiveRecord::Base
+    #          acts_as_solr :if => proc{|record| record.is_active?}
+    #        end
+    # 
+    # offline:: Assumes that your using an outside mechanism to explicitly trigger indexing records, e.g. you only
+    #           want to update your index through some asynchronous mechanism. Will accept either a boolean or a block
+    #           that will be evaluated before actually contacting the index for saving or destroying a document. Defaults
+    #           to false. It doesn't refer to the mechanism of an offline index in general, but just to get a centralized point
+    #           where you can control indexing. Note: This is only enabled for saving records. acts_as_solr doesn't always like
+    #           it, if you have a different number of results coming from the database and the index. This might be rectified in
+    #           another patch to support lazy loading.
+    #
+    #             class Electronic < ActiveRecord::Base
+    #               acts_as_solr :offline => proc {|record| record.automatic_indexing_disabled?}
+    #             end
+    #
+    # auto_commit:: The commit command will be sent to Solr only if its value is set to true:
+    # 
+    #                 class Author < ActiveRecord::Base
+    #                   acts_as_solr :auto_commit => false
+    #                 end
+    # 
+    def acts_as_solr(options={}, solr_options={})
+      
+      extend ClassMethods
+      include InstanceMethods
+      include CommonMethods
+      include ParserMethods
+      
+      cattr_accessor :configuration
+      cattr_accessor :solr_configuration
+      
+      self.configuration = { 
+        :fields => nil,
+        :additional_fields => nil,
+        :exclude_fields => [],
+        :auto_commit => true,
+        :include => nil,
+        :facets => nil,
+        :boost => nil,
+        :if => "true",
+        :offline => false
+      }  
+      self.solr_configuration = {
+        :type_field => "type_s",
+        :primary_key_field => "pk_i",
+        :default_boost => 1.0
+      }
+      
+      configuration.update(options) if options.is_a?(Hash)
+      solr_configuration.update(solr_options) if solr_options.is_a?(Hash)
+      Deprecation.validate_index(configuration)
+      
+      configuration[:solr_fields] = {}
+      configuration[:solr_includes] = {}
+      
+      after_save    :solr_save
+      after_destroy :solr_destroy
+
+      if configuration[:fields].respond_to?(:each)
+        process_fields(configuration[:fields])
+      else
+        process_fields(self.new.attributes.keys.map { |k| k.to_sym })
+        process_fields(configuration[:additional_fields])
+      end
+
+      if configuration[:include].respond_to?(:each)
+        process_includes(configuration[:include])
+      end
+    end
+    
+    private
+    def get_field_value(field)
+      field_name, options = determine_field_name_and_options(field)
+      configuration[:solr_fields][field_name] = options
+      
+      define_method("#{field_name}_for_solr".to_sym) do
+        begin
+          value = self[field_name] || self.instance_variable_get("@#{field_name.to_s}".to_sym) || self.send(field_name.to_sym)
+          case options[:type] 
+            # format dates properly; return nil for nil dates 
+            when :date
+              value ? (value.respond_to?(:utc) ? value.utc : value).strftime("%Y-%m-%dT%H:%M:%SZ") : nil 
+            else value
+          end
+        rescue
+          puts $!
+          logger.debug "There was a problem getting the value for the field '#{field_name}': #{$!}"
+          value = ''
+        end
+      end
+    end
+    
+    def process_fields(raw_field)
+      if raw_field.respond_to?(:each)
+        raw_field.each do |field|
+          next if configuration[:exclude_fields].include?(field)
+          get_field_value(field)
+        end                
+      end
+    end
+    
+    def process_includes(includes)
+      if includes.respond_to?(:each)
+        includes.each do |assoc|
+          field_name, options = determine_field_name_and_options(assoc)
+          configuration[:solr_includes][field_name] = options
+        end
+      end
+    end
+
+    def determine_field_name_and_options(field)
+      if field.is_a?(Hash)
+        name = field.keys.first
+        options = field.values.first
+        if options.is_a?(Hash)
+          [name, {:type => type_for_field(field)}.merge(options)]
+        else
+          [name, {:type => options}]
+        end
+      else
+        [field, {:type => type_for_field(field)}]
+      end
+    end
+    
+    def type_for_field(field)
+      if configuration[:facets] && configuration[:facets].include?(field)
+        :facet
+      elsif column = columns_hash[field.to_s]
+        case column.type
+        when :string then :text
+        when :datetime then :date
+        when :time then :date
+        else column.type
+        end
+      else
+        :text
+      end
+    end
+  end
+end
 \ No newline at end of file
@@ -0,0 +1,239 @@
+require File.dirname(__FILE__) + '/common_methods'
+require File.dirname(__FILE__) + '/parser_methods'
+
+module ActsAsSolr #:nodoc:
+
+  module ClassMethods
+    include CommonMethods
+    include ParserMethods
+    
+    # Finds instances of a model. Terms are ANDed by default, can be overwritten 
+    # by using OR between terms
+    # 
+    # Here's a sample (untested) code for your controller:
+    # 
+    #  def search
+    #    results = Book.find_by_solr params[:query]
+    #  end
+    # 
+    # You can also search for specific fields by searching for 'field:value'
+    # 
+    # ====options:
+    # offset:: - The first document to be retrieved (offset)
+    # limit:: - The number of rows per page
+    # order:: - Orders (sort by) the result set using a given criteria:
+    #
+    #             Book.find_by_solr 'ruby', :order => 'description asc'
+    # 
+    # field_types:: This option is deprecated and will be obsolete by version 1.0.
+    #               There's no need to specify the :field_types anymore when doing a 
+    #               search in a model that specifies a field type for a field. The field 
+    #               types are automatically traced back when they're included.
+    # 
+    #                 class Electronic < ActiveRecord::Base
+    #                   acts_as_solr :fields => [{:price => :range_float}]
+    #                 end
+    # 
+    # facets:: This option argument accepts the following arguments:
+    #          fields:: The fields to be included in the faceted search (Solr's facet.field)
+    #          query:: The queries to be included in the faceted search (Solr's facet.query)
+    #          zeros:: Display facets with count of zero. (true|false)
+    #          sort:: Sorts the faceted resuls by highest to lowest count. (true|false)
+    #          browse:: This is where the 'drill-down' of the facets work. Accepts an array of
+    #                   fields in the format "facet_field:term"
+    #          mincount:: Replacement for zeros (it has been deprecated in Solr). Specifies the
+    #                     minimum count necessary for a facet field to be returned. (Solr's
+    #                     facet.mincount) Overrides :zeros if it is specified. Default is 0.
+    #
+    #          dates:: Run date faceted queries using the following arguments:
+    #            fields:: The fields to be included in the faceted date search (Solr's facet.date).
+    #                     It may be either a String/Symbol or Hash. If it's a hash the options are the
+    #                     same as date_facets minus the fields option (i.e., :start:, :end, :gap, :other,
+    #                     :between). These options if provided will override the base options.
+    #                     (Solr's f.<field_name>.date.<key>=<value>).
+    #            start:: The lower bound for the first date range for all Date Faceting. Required if
+    #                    :fields is present
+    #            end:: The upper bound for the last date range for all Date Faceting. Required if
+    #                  :fields is prsent
+    #            gap:: The size of each date range expressed as an interval to be added to the lower
+    #                  bound using the DateMathParser syntax.  Required if :fields is prsent
+    #            hardend:: A Boolean parameter instructing Solr what do do in the event that
+    #                      facet.date.gap does not divide evenly between facet.date.start and facet.date.end.
+    #            other:: This param indicates that in addition to the counts for each date range
+    #                    constraint between facet.date.start and facet.date.end, other counds should be
+    #                    calculated. May specify more then one in an Array. The possible options are:
+    #              before:: - all records with lower bound less than start
+    #              after:: - all records with upper bound greater than end
+    #              between:: - all records with field values between start and end
+    #              none:: - compute no other bounds (useful in per field assignment)
+    #              all:: - shortcut for before, after, and between
+    #            filter:: Similar to :query option provided by :facets, in that accepts an array of
+    #                     of date queries to limit results. Can not be used as a part of a :field hash.
+    #                     This is the only option that can be used if :fields is not present.
+    # 
+    # Example:
+    # 
+    #   Electronic.find_by_solr "memory", :facets => {:zeros => false, :sort => true,
+    #                                                 :query => ["price:[* TO 200]",
+    #                                                            "price:[200 TO 500]",
+    #                                                            "price:[500 TO *]"],
+    #                                                 :fields => [:category, :manufacturer],
+    #                                                 :browse => ["category:Memory","manufacturer:Someone"]}
+    # 
+    #
+    # Examples of date faceting:
+    #
+    #  basic:
+    #    Electronic.find_by_solr "memory", :facets => {:dates => {:fields => [:updated_at, :created_at],
+    #      :start => 'NOW-10YEARS/DAY', :end => 'NOW/DAY', :gap => '+2YEARS', :other => :before}}
+    #
+    #  advanced:
+    #    Electronic.find_by_solr "memory", :facets => {:dates => {:fields => [:updated_at,
+    #    {:created_at => {:start => 'NOW-20YEARS/DAY', :end => 'NOW-10YEARS/DAY', :other => [:before, :after]}
+    #    }], :start => 'NOW-10YEARS/DAY', :end => 'NOW/DAY', :other => :before, :filter =>
+    #    ["created_at:[NOW-10YEARS/DAY TO NOW/DAY]", "updated_at:[NOW-1YEAR/DAY TO NOW/DAY]"]}}
+    #
+    #  filter only:
+    #    Electronic.find_by_solr "memory", :facets => {:dates => {:filter => "updated_at:[NOW-1YEAR/DAY TO NOW/DAY]"}}
+    #
+    #
+    #
+    # scores:: If set to true this will return the score as a 'solr_score' attribute
+    #          for each one of the instances found. Does not currently work with find_id_by_solr
+    # 
+    #            books = Book.find_by_solr 'ruby OR splinter', :scores => true
+    #            books.records.first.solr_score
+    #            => 1.21321397
+    #            books.records.last.solr_score
+    #            => 0.12321548
+    # 
+    # lazy:: If set to true the search will return objects that will touch the database when you ask for one
+    #        of their attributes for the first time. Useful when you're using fragment caching based solely on
+    #        types and ids.
+    #
+    def find_by_solr(query, options={})
+      data = parse_query(query, options)
+      return parse_results(data, options) if data
+    end
+    
+    # Finds instances of a model and returns an array with the ids:
+    #  Book.find_id_by_solr "rails" => [1,4,7]
+    # The options accepted are the same as find_by_solr
+    # 
+    def find_id_by_solr(query, options={})
+      data = parse_query(query, options)
+      return parse_results(data, {:format => :ids}) if data
+    end
+    
+    # This method can be used to execute a search across multiple models:
+    #   Book.multi_solr_search "Napoleon OR Tom", :models => [Movie]
+    # 
+    # ====options:
+    # Accepts the same options as find_by_solr plus:
+    # models:: The additional models you'd like to include in the search
+    # results_format:: Specify the format of the results found
+    #                  :objects :: Will return an array with the results being objects (default). Example:
+    #                               Book.multi_solr_search "Napoleon OR Tom", :models => [Movie], :results_format => :objects
+    #                  :ids :: Will return an array with the ids of each entry found. Example:
+    #                           Book.multi_solr_search "Napoleon OR Tom", :models => [Movie], :results_format => :ids
+    #                           => [{"id" => "Movie:1"},{"id" => Book:1}]
+    #                          Where the value of each array is as Model:instance_id
+    # scores:: If set to true this will return the score as a 'solr_score' attribute
+    #          for each one of the instances found. Does not currently work with find_id_by_solr
+    # 
+    #            books = Book.multi_solr_search 'ruby OR splinter', :scores => true
+    #            books.records.first.solr_score
+    #            => 1.21321397
+    #            books.records.last.solr_score
+    #            => 0.12321548
+    # 
+    def multi_solr_search(query, options = {})
+      models = multi_model_suffix(options)
+      options.update(:results_format => :objects) unless options[:results_format]
+      data = parse_query(query, options, models)
+      
+      if data.nil? or data.total_hits == 0
+        return SearchResults.new(:docs => [], :total => 0)
+      end
+
+      result = find_multi_search_objects(data, options)
+      if options[:scores] and options[:results_format] == :objects
+        add_scores(result, data) 
+      end
+      SearchResults.new :docs => result, :total => data.total_hits
+    end
+
+    def find_multi_search_objects(data, options)
+      result = []
+      if options[:results_format] == :objects
+        data.hits.each do |doc| 
+          k = doc.fetch('id').first.to_s.split(':')
+          result << k[0].constantize.find_by_id(k[1])
+        end
+      elsif options[:results_format] == :ids
+        data.hits.each{|doc| result << {"id" => doc.values.pop.to_s}}
+      end
+      result
+    end
+    
+    def multi_model_suffix(options)
+      models = "AND (#{solr_configuration[:type_field]}:#{self.name}"
+      models << " OR " + options[:models].collect {|m| "#{solr_configuration[:type_field]}:" + m.to_s}.join(" OR ") if options[:models].is_a?(Array)
+      models << ")"
+    end
+    
+    # returns the total number of documents found in the query specified:
+    #  Book.count_by_solr 'rails' => 3
+    # 
+    def count_by_solr(query, options = {})        
+      data = parse_query(query, options)
+      data.total_hits
+    end
+            
+    # It's used to rebuild the Solr index for a specific model. 
+    #  Book.rebuild_solr_index
+    # 
+    # If batch_size is greater than 0, adds will be done in batches.
+    # NOTE: If using sqlserver, be sure to use a finder with an explicit order.
+    # Non-edge versions of rails do not handle pagination correctly for sqlserver
+    # without an order clause.
+    # 
+    # If a finder block is given, it will be called to retrieve the items to index.
+    # This can be very useful for things such as updating based on conditions or
+    # using eager loading for indexed associations.
+    def rebuild_solr_index(batch_size=100, &finder)
+      finder ||= lambda { |ar, options| ar.find(:all, options.merge({:order => self.primary_key})) }
+      start_time = Time.now
+
+      if batch_size > 0
+        items_processed = 0
+        limit = batch_size
+        offset = 0
+        begin
+          iteration_start = Time.now
+          items = finder.call(self, {:limit => limit, :offset => offset})
+          add_batch = items.collect { |content| content.to_solr_doc }
+    
+          if items.size > 0
+            solr_add add_batch
+            solr_commit
+          end
+    
+          items_processed += items.size
+          last_id = items.last.id if items.last
+          time_so_far = Time.now - start_time
+          iteration_time = Time.now - iteration_start         
+          logger.info "#{Process.pid}: #{items_processed} items for #{self.name} have been batch added to index in #{'%.3f' % time_so_far}s at #{'%.3f' % (items_processed / time_so_far)} items/sec (#{'%.3f' % (items.size / iteration_time)} items/sec for the last batch). Last id: #{last_id}"
+          offset += items.size
+        end while items.nil? || items.size > 0
+      else
+        items = finder.call(self, {})
+        items.each { |content| content.solr_save }
+        items_processed = items.size
+      end
+      solr_optimize
+      logger.info items_processed > 0 ? "Index for #{self.name} has been rebuilt" : "Nothing to index for #{self.name}"
+    end
+  end
+  
+end
@@ -0,0 +1,89 @@
+module ActsAsSolr #:nodoc:
+  
+  module CommonMethods
+    
+    # Converts field types into Solr types
+    def get_solr_field_type(field_type)
+      if field_type.is_a?(Symbol)
+        case field_type
+          when :float
+            return "f"
+          when :integer
+            return "i"
+          when :boolean
+            return "b"
+          when :string
+            return "s"
+          when :date
+            return "d"
+          when :range_float
+            return "rf"
+          when :range_integer
+            return "ri"
+          when :facet
+            return "facet"
+          when :text
+            return "t"
+        else
+          raise "Unknown field_type symbol: #{field_type}"
+        end
+      elsif field_type.is_a?(String)
+        return field_type
+      else
+        raise "Unknown field_type class: #{field_type.class}: #{field_type}"
+      end
+    end
+    
+    # Sets a default value when value being set is nil.
+    def set_value_if_nil(field_type)
+      case field_type
+        when "b", :boolean
+          return "false"
+        when "s", "t", "d", :date, :string, :text
+          return ""
+        when "f", "rf", :float, :range_float
+          return 0.00
+        when "i", "ri", :integer, :range_integer
+          return 0
+      else
+        return ""
+      end
+    end
+    
+    # Sends an add command to Solr
+    def solr_add(add_xml)
+      ActsAsSolr::Post.execute(Solr::Request::AddDocument.new(add_xml))
+    end
+    
+    # Sends the delete command to Solr
+    def solr_delete(solr_ids)
+      ActsAsSolr::Post.execute(Solr::Request::Delete.new(:id => solr_ids))
+    end
+    
+    # Sends the commit command to Solr
+    def solr_commit
+      ActsAsSolr::Post.execute(Solr::Request::Commit.new)
+    end
+    
+    # Optimizes the Solr index. Solr says:
+    # 
+    # Optimizations can take nearly ten minutes to run. 
+    # We are presuming optimizations should be run once following large 
+    # batch-like updates to the collection and/or once a day.
+    # 
+    # One of the solutions for this would be to create a cron job that 
+    # runs every day at midnight and optmizes the index:
+    #   0 0 * * * /your_rails_dir/script/runner -e production "Model.solr_optimize"
+    # 
+    def solr_optimize
+      ActsAsSolr::Post.execute(Solr::Request::Optimize.new)
+    end
+    
+    # Returns the id for the given instance
+    def record_id(object)
+      eval "object.#{object.class.primary_key}"
+    end
+    
+  end
+  
+end
 \ No newline at end of file
@@ -0,0 +1,61 @@
+module ActsAsSolr #:nodoc:
+  
+  class Post
+    def initialize(body, mode = :search)
+      @body = body
+      @mode = mode
+      puts "The method ActsAsSolr::Post.new(body, mode).execute_post is depracated. " +
+           "Use ActsAsSolr::Post.execute(body, mode) instead!"
+    end
+    
+    def execute_post
+      ActsAsSolr::Post.execute(@body, @mode)
+    end    
+  end
+  
+  module ClassMethods
+    def find_with_facet(query, options={})
+      Deprecation.plog "The method find_with_facet is deprecated. Use find_by_solr instead, passing the " +
+                       "arguments the same way you used to do with find_with_facet."
+      find_by_solr(query, options)
+    end
+  end
+  
+  class Deprecation
+    # Validates the options passed during query
+    def self.validate_query options={}
+      if options[:field_types]
+        plog "The option :field_types for searching is deprecated. " +
+             "The field types are automatically traced back when you specify a field type in your model."
+      end
+      if options[:sort_by]
+        plog "The option :sort_by is deprecated, use :order instead!"
+        options[:order] ||= options[:sort_by]
+      end
+      if options[:start]
+        plog "The option :start is deprecated, use :offset instead!"
+        options[:offset] ||= options[:start]
+      end
+      if options[:rows]
+        plog "The option :rows is deprecated, use :limit instead!"
+        options[:limit] ||= options[:rows]
+      end
+    end
+    
+    # Validates the options passed during indexing
+    def self.validate_index options={}
+      if options[:background]
+        plog "The :background option is being deprecated. There are better and more efficient " +
+             "ways to handle delayed saving of your records."
+      end
+    end
+    
+    # This will print the text to stdout and log the text
+    # if rails logger is available
+    def self.plog text
+      puts text
+      RAILS_DEFAULT_LOGGER.warn text if defined? RAILS_DEFAULT_LOGGER
+    end
+  end
+  
+end
@@ -0,0 +1,166 @@
+module ActsAsSolr #:nodoc:
+  
+  module InstanceMethods
+
+    # Solr id is <class.name>:<id> to be unique across all models
+    def solr_id
+      "#{self.class.name}:#{record_id(self)}"
+    end
+
+    # saves to the Solr index
+    def solr_save
+      return true if indexing_disabled?
+      if evaluate_condition(:if, self) 
+        logger.debug "solr_save: #{self.class.name} : #{record_id(self)}"
+        solr_add to_solr_doc
+        solr_commit if configuration[:auto_commit]
+        true
+      else
+        solr_destroy
+      end
+    end
+
+    def indexing_disabled?
+      evaluate_condition(:offline, self) || !configuration[:if]
+    end
+
+    # remove from index
+    def solr_destroy
+      return true if indexing_disabled?
+      logger.debug "solr_destroy: #{self.class.name} : #{record_id(self)}"
+      solr_delete solr_id
+      solr_commit if configuration[:auto_commit]
+      true
+    end
+
+    # convert instance to Solr document
+    def to_solr_doc
+      logger.debug "to_solr_doc: creating doc for class: #{self.class.name}, id: #{record_id(self)}"
+      doc = Solr::Document.new
+      doc.boost = validate_boost(configuration[:boost]) if configuration[:boost]
+      
+      doc << {:id => solr_id,
+              solr_configuration[:type_field] => self.class.name,
+              solr_configuration[:primary_key_field] => record_id(self).to_s}
+
+      # iterate through the fields and add them to the document,
+      configuration[:solr_fields].each do |field_name, options|
+        #field_type = configuration[:facets] && configuration[:facets].include?(field) ? :facet : :text
+        
+        field_boost = options[:boost] || solr_configuration[:default_boost]
+        field_type = get_solr_field_type(options[:type])
+        solr_name = options[:as] || field_name
+        
+        value = self.send("#{field_name}_for_solr")
+        value = set_value_if_nil(field_type) if value.to_s == ""
+        
+        # add the field to the document, but only if it's not the id field
+        # or the type field (from single table inheritance), since these
+        # fields have already been added above.
+        if field_name.to_s != self.class.primary_key and field_name.to_s != "type"
+          suffix = get_solr_field_type(field_type)
+          # This next line ensures that e.g. nil dates are excluded from the 
+          # document, since they choke Solr. Also ignores e.g. empty strings, 
+          # but these can't be searched for anyway: 
+          # http://www.mail-archive.com/solr-dev@lucene.apache.org/msg05423.html
+          next if value.nil? || value.to_s.strip.empty?
+          [value].flatten.each do |v|
+            v = set_value_if_nil(suffix) if value.to_s == ""
+            field = Solr::Field.new("#{solr_name}_#{suffix}" => ERB::Util.html_escape(v.to_s))
+            field.boost = validate_boost(field_boost)
+            doc << field
+          end
+        end
+      end
+      
+      add_includes(doc)
+      logger.debug doc.to_xml
+      doc
+    end
+    
+    private
+    def add_includes(doc)
+      if configuration[:solr_includes].respond_to?(:each)
+        configuration[:solr_includes].each do |association, options|
+          data = options[:multivalued] ? [] : ""
+          field_name = options[:as] || association.to_s.singularize
+          field_type = get_solr_field_type(options[:type])
+          field_boost = options[:boost] || solr_configuration[:default_boost]
+          suffix = get_solr_field_type(field_type)
+          case self.class.reflect_on_association(association).macro
+          when :has_many, :has_and_belongs_to_many
+            records = self.send(association).to_a
+            unless records.empty?
+              records.each {|r| data << include_value(r, options)}
+              [data].flatten.each do |value|
+                field = Solr::Field.new("#{field_name}_#{suffix}" => value)
+                field.boost = validate_boost(field_boost)
+                doc << field
+              end
+            end
+          when :has_one, :belongs_to
+            record = self.send(association)
+            unless record.nil?
+              doc["#{field_name}_#{suffix}"] = include_value(record, options)
+            end
+          end
+        end
+      end
+    end
+    
+    def include_value(record, options)
+      if options[:using].is_a? Proc
+        options[:using].call(record)
+      elsif options[:using].is_a? Symbol
+        record.send(options[:using])
+      else
+        record.attributes.inject([]){|k,v| k << "#{v.first}=#{ERB::Util.html_escape(v.last)}"}.join(" ")
+      end
+    end
+
+    def validate_boost(boost)
+      boost_value = case boost
+      when Float
+        return solr_configuration[:default_boost] if boost < 0
+        boost
+      when Proc
+        boost.call(self)
+      when Symbol
+        if self.respond_to?(boost)
+          self.send(boost)
+        end
+      end
+      
+      boost_value || solr_configuration[:default_boost]
+    end
+    
+    def condition_block?(condition)
+      condition.respond_to?("call") && (condition.arity == 1 || condition.arity == -1)
+    end
+    
+    def evaluate_condition(which_condition, field)
+      condition = configuration[which_condition]
+      case condition
+        when Symbol
+          field.send(condition)
+        when String
+          eval(condition, binding)
+        when FalseClass, NilClass
+          false
+        when TrueClass
+          true
+        else
+          if condition_block?(condition)
+            condition.call(field)
+          else
+            raise(
+              ArgumentError,
+              "The :#{which_condition} option has to be either a symbol, string (to be eval'ed), proc/method, true/false, or " +
+              "class implementing a static validation method"
+            )
+          end
+        end
+    end
+    
+  end
+end
 \ No newline at end of file
@@ -0,0 +1,18 @@
+module ActsAsSolr
+  class LazyDocument
+    attr_reader :id, :clazz
+    
+    def initialize(id, clazz)
+      @id = id
+      @clazz = clazz
+    end
+  
+    def method_missing(name, *args)
+      unless @__instance
+        @__instance = @clazz.find(@id)
+      end
+      
+      @__instance.send(name, *args)
+    end
+  end
+end
 \ No newline at end of file
@@ -0,0 +1,201 @@
+module ActsAsSolr #:nodoc:
+  module ParserMethods
+    protected    
+    
+    # Method used by mostly all the ClassMethods when doing a search
+    def parse_query(query=nil, options={}, models=nil)
+      valid_options = [:offset, :limit, :facets, :models, :results_format, :order, :scores, :operator, :include, :lazy]
+      query_options = {}
+
+      return nil if (query.nil? || query.strip == '')
+
+      raise "Invalid parameters: #{(options.keys - valid_options).join(',')}" unless (options.keys - valid_options).empty?
+      begin
+        Deprecation.validate_query(options)
+        query_options[:start] = options[:offset]
+        query_options[:rows] = options[:limit]
+        query_options[:operator] = options[:operator]
+        
+        # first steps on the facet parameter processing
+        if options[:facets]
+          query_options[:facets] = {}
+          query_options[:facets][:limit] = -1  # TODO: make this configurable
+          query_options[:facets][:sort] = :count if options[:facets][:sort]
+          query_options[:facets][:mincount] = 0
+          query_options[:facets][:mincount] = 1 if options[:facets][:zeros] == false
+          # override the :zeros (it's deprecated anyway) if :mincount exists
+          query_options[:facets][:mincount] = options[:facets][:mincount] if options[:facets][:mincount]
+          query_options[:facets][:fields] = options[:facets][:fields].collect{|k| "#{k}_facet"} if options[:facets][:fields]
+          query_options[:filter_queries] = replace_types([*options[:facets][:browse]].collect{|k| "#{k.sub!(/ *: */,"_facet:")}"}) if options[:facets][:browse]
+          query_options[:facets][:queries] = replace_types(options[:facets][:query].collect{|k| "#{k.sub!(/ *: */,"_t:")}"}) if options[:facets][:query]
+          
+          
+          if options[:facets][:dates]
+            query_options[:date_facets] = {}
+            # if options[:facets][:dates][:fields] exists then :start, :end, and :gap must be there
+            if options[:facets][:dates][:fields]
+              [:start, :end, :gap].each { |k| raise "#{k} must be present in faceted date query" unless options[:facets][:dates].include?(k) }
+              query_options[:date_facets][:fields] = []
+              options[:facets][:dates][:fields].each { |f|
+                if f.kind_of? Hash
+                  key = f.keys[0]
+                  query_options[:date_facets][:fields] << {"#{key}_d" => f[key]}
+                  validate_date_facet_other_options(f[key][:other]) if f[key][:other]
+                else
+                  query_options[:date_facets][:fields] << "#{f}_d"
+                end
+              }
+            end
+            
+            query_options[:date_facets][:start]   = options[:facets][:dates][:start] if options[:facets][:dates][:start]
+            query_options[:date_facets][:end]     = options[:facets][:dates][:end] if options[:facets][:dates][:end]
+            query_options[:date_facets][:gap]     = options[:facets][:dates][:gap] if options[:facets][:dates][:gap]
+            query_options[:date_facets][:hardend] = options[:facets][:dates][:hardend] if options[:facets][:dates][:hardend]
+            query_options[:date_facets][:filter]  = replace_types([*options[:facets][:dates][:filter]].collect{|k| "#{k.sub!(/ *:(?!\d) */,"_d:")}"}) if options[:facets][:dates][:filter]
+
+            if options[:facets][:dates][:other]
+              validate_date_facet_other_options(options[:facets][:dates][:other])
+              query_options[:date_facets][:other]   = options[:facets][:dates][:other]
+            end
+            
+          end          
+        end
+        
+        if models.nil?
+          # TODO: use a filter query for type, allowing Solr to cache it individually
+          models = "AND #{solr_type_condition}"
+          field_list = solr_configuration[:primary_key_field]
+        else
+          field_list = "id"
+        end
+        
+        query_options[:field_list] = [field_list, 'score']
+        query = "(#{query.gsub(/ *: */,"_t:")}) #{models}"
+        order = options[:order].split(/\s*,\s*/).collect{|e| e.gsub(/\s+/,'_t ').gsub(/\bscore_t\b/, 'score')  }.join(',') if options[:order] 
+        query_options[:query] = replace_types([query])[0] # TODO adjust replace_types to work with String or Array  
+
+        if options[:order]
+          # TODO: set the sort parameter instead of the old ;order. style.
+          query_options[:query] << ';' << replace_types([order], false)[0]
+        end
+        
+        ActsAsSolr::Post.execute(Solr::Request::Standard.new(query_options))
+      rescue
+        raise "There was a problem executing your search: #{$!} in #{$!.backtrace.first}"
+      end            
+    end
+    
+    def solr_type_condition
+      subclasses.inject("(#{solr_configuration[:type_field]}:#{self.name}") do |condition, subclass|
+        condition << " OR #{solr_configuration[:type_field]}:#{subclass.name}"
+      end << ')'
+    end
+    
+    # Parses the data returned from Solr
+    def parse_results(solr_data, options = {})
+      results = {
+        :docs => [],
+        :total => 0
+      }
+      
+      configuration = {
+        :format => :objects
+      }
+      results.update(:facets => {'facet_fields' => []}) if options[:facets]
+      return SearchResults.new(results) if (solr_data.nil? || solr_data.total_hits == 0)
+      
+      configuration.update(options) if options.is_a?(Hash)
+
+      ids = solr_data.hits.collect {|doc| doc["#{solr_configuration[:primary_key_field]}"]}.flatten
+      
+      result = find_objects(ids, options, configuration)
+      
+      add_scores(result, solr_data) if configuration[:format] == :objects && options[:scores]
+      
+      results.update(:facets => solr_data.data['facet_counts']) if options[:facets]
+      results.update({:docs => result, :total => solr_data.total_hits, :max_score => solr_data.max_score, :query_time => solr_data.data['responseHeader']['QTime']})
+      SearchResults.new(results)
+    end
+    
+    
+    def find_objects(ids, options, configuration)
+      result = if configuration[:lazy] && configuration[:format] != :ids
+        ids.collect {|id| ActsAsSolr::LazyDocument.new(id, self)}
+      elsif configuration[:format] == :objects
+        conditions = [ "#{self.table_name}.#{primary_key} in (?)", ids ]
+        find_options = {:conditions => conditions}
+        find_options[:include] = options[:include] if options[:include]
+        result = reorder(self.find(:all, find_options), ids)
+      else
+        ids
+      end
+        
+      result
+    end
+    
+    # Reorders the instances keeping the order returned from Solr
+    def reorder(things, ids)
+      ordered_things = Array.new(things.size)
+      raise "Out of sync! Found #{ids.size} items in index, but only #{things.size} were found in database!" unless things.size == ids.size
+      things.each do |thing|
+        position = ids.index(thing.id)
+        ordered_things[position] = thing
+      end
+      ordered_things
+    end
+
+    # Replaces the field types based on the types (if any) specified
+    # on the acts_as_solr call
+    def replace_types(strings, include_colon=true)
+      suffix = include_colon ? ":" : ""
+      if configuration[:solr_fields]
+        configuration[:solr_fields].each do |name, options|
+          solr_name = options[:as] || name.to_s
+          solr_type = get_solr_field_type(options[:type])
+          field = "#{solr_name}_#{solr_type}#{suffix}"
+          strings.each_with_index {|s,i| strings[i] = s.gsub(/#{solr_name.to_s}_t#{suffix}/,field) }
+        end
+      end
+      if configuration[:solr_includes]
+        configuration[:solr_includes].each do |association, options|
+          solr_name = options[:as] || association.to_s.singularize
+          solr_type = get_solr_field_type(options[:type])
+          field = "#{solr_name}_#{solr_type}#{suffix}"
+          strings.each_with_index {|s,i| strings[i] = s.gsub(/#{solr_name.to_s}_t#{suffix}/,field) }
+        end
+      end
+      strings
+    end
+    
+    # Adds the score to each one of the instances found
+    def add_scores(results, solr_data)
+      with_score = []
+      solr_data.hits.each do |doc|
+        with_score.push([doc["score"], 
+          results.find {|record| scorable_record?(record, doc) }])
+      end
+      with_score.each do |score, object| 
+        class << object; attr_accessor :solr_score; end
+        object.solr_score = score
+      end
+    end
+    
+    def scorable_record?(record, doc)
+      doc_id = doc["#{solr_configuration[:primary_key_field]}"]
+      if doc_id.nil?
+        doc_id = doc["id"]
+        "#{record.class.name}:#{record_id(record)}" == doc_id.first.to_s
+      else
+        record_id(record).to_s == doc_id.to_s
+      end
+    end
+    
+    def validate_date_facet_other_options(options)
+      valid_other_options = [:after, :all, :before, :between, :none]
+      options = [options] unless options.kind_of? Array
+      bad_options = options.map {|x| x.to_sym} - valid_other_options
+      raise "Invalid option#{'s' if bad_options.size > 1} for faceted date's other param: #{bad_options.join(', ')}. May only be one of :after, :all, :before, :between, :none" if bad_options.size > 0
+    end
+    
+  end
+end
 \ No newline at end of file
@@ -0,0 +1,68 @@
+module ActsAsSolr #:nodoc:
+  
+  # TODO: Possibly looking into hooking it up with Solr::Response::Standard
+  # 
+  # Class that returns the search results with four methods.
+  # 
+  #   books = Book.find_by_solr 'ruby'
+  # 
+  # the above will return a SearchResults class with 4 methods:
+  # 
+  # docs|results|records: will return an array of records found
+  # 
+  #   books.records.empty?
+  #   => false
+  # 
+  # total|num_found|total_hits: will return the total number of records found
+  # 
+  #   books.total
+  #   => 2
+  # 
+  # facets: will return the facets when doing a faceted search
+  # 
+  # max_score|highest_score: returns the highest score found
+  # 
+  #   books.max_score
+  #   => 1.3213213
+  # 
+  # 
+  class SearchResults
+    def initialize(solr_data={})
+      @solr_data = solr_data
+    end
+    
+    # Returns an array with the instances. This method
+    # is also aliased as docs and records
+    def results
+      @solr_data[:docs]
+    end
+    
+    # Returns the total records found. This method is
+    # also aliased as num_found and total_hits
+    def total
+      @solr_data[:total]
+    end
+    
+    # Returns the facets when doing a faceted search
+    def facets
+      @solr_data[:facets]
+    end
+    
+    # Returns the highest score found. This method is
+    # also aliased as highest_score
+    def max_score
+      @solr_data[:max_score]
+    end
+    
+    def query_time
+      @solr_data[:query_time]
+    end
+    
+    alias docs results
+    alias records results
+    alias num_found total
+    alias total_hits total
+    alias highest_score max_score
+  end
+  
+end
 \ No newline at end of file
@@ -0,0 +1,21 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Solr; end
+require 'solr/exception'
+require 'solr/request'
+require 'solr/connection'
+require 'solr/response'
+require 'solr/util'
+require 'solr/xml'
+require 'solr/importer'
+require 'solr/indexer'
@@ -0,0 +1,179 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'net/http'
+
+# TODO: add a convenience method to POST a Solr .xml file, like Solr's example post.sh
+
+class Solr::Connection
+  attr_reader :url, :autocommit, :connection
+
+  # create a connection to a solr instance using the url for the solr
+  # application context:
+  #
+  #   conn = Solr::Connection.new("http://example.com:8080/solr")
+  #
+  # if you would prefer to have all adds/updates autocommitted, 
+  # use :autocommit => :on
+  #
+  #   conn = Solr::Connection.new('http://example.com:8080/solr', 
+  #     :autocommit => :on)
+
+  def initialize(url="http://localhost:8983/solr", opts={})
+    @url = URI.parse(url)
+    unless @url.kind_of? URI::HTTP
+      raise "invalid http url: #{url}"
+    end
+  
+    # TODO: Autocommit seems nice at one level, but it currently is confusing because
+    # only calls to Connection#add/#update/#delete, though a Connection#send(AddDocument.new(...))
+    # does not autocommit.  Maybe #send should check for the request types that require a commit and
+    # commit in #send instead of the individual methods?
+    @autocommit = opts[:autocommit] == :on
+  
+    # Not actually opening the connection yet, just setting up the persistent connection.
+    @connection = Net::HTTP.new(@url.host, @url.port)
+    
+    @connection.read_timeout = opts[:timeout] if opts[:timeout]
+  end
+
+  # add a document to the index. you can pass in either a hash
+  #
+  #   conn.add(:id => 123, :title => 'Tlon, Uqbar, Orbis Tertius')
+  #
+  # or a Solr::Document
+  #
+  #   conn.add(Solr::Document.new(:id => 123, :title = 'On Writing')
+  #
+  # true/false will be returned to designate success/failure
+
+  def add(doc)
+    request = Solr::Request::AddDocument.new(doc)
+    response = send(request)
+    commit if @autocommit
+    return response.ok?
+  end
+
+  # update a document in the index (really just an alias to add)
+
+  def update(doc)
+    return add(doc)
+  end
+
+  # performs a standard query and returns a Solr::Response::Standard
+  #
+  #   response = conn.query('borges')
+  # 
+  # alternative you can pass in a block and iterate over hits
+  #
+  #   conn.query('borges') do |hit|
+  #     puts hit
+  #   end
+  #
+  # options include:
+  # 
+  #   :sort, :default_field, :rows, :filter_queries, :debug_query,
+  #   :explain_other, :facets, :highlighting, :mlt,
+  #   :operator         => :or / :and
+  #   :start            => defaults to 0
+  #   :field_list       => array, defaults to ["*", "score"]
+
+  def query(query, options={}, &action)
+    # TODO: Shouldn't this return an exception if the Solr status is not ok?  (rather than true/false).
+    create_and_send_query(Solr::Request::Standard, options.update(:query => query), &action)
+  end
+  
+  # performs a dismax search and returns a Solr::Response::Standard
+  #
+  #   response = conn.search('borges')
+  # 
+  # options are same as query, but also include:
+  # 
+  #   :tie_breaker, :query_fields, :minimum_match, :phrase_fields,
+  #   :phrase_slop, :boost_query, :boost_functions
+
+  def search(query, options={}, &action)
+    create_and_send_query(Solr::Request::Dismax, options.update(:query => query), &action)
+  end
+
+  # sends a commit message to the server
+  def commit(options={})
+    response = send(Solr::Request::Commit.new(options))
+    return response.ok?
+  end
+
+  # sends an optimize message to the server
+  def optimize
+    response = send(Solr::Request::Optimize.new)
+    return response.ok?
+  end
+  
+  # pings the connection and returns true/false if it is alive or not
+  def ping
+    begin
+      response = send(Solr::Request::Ping.new)
+      return response.ok?
+    rescue
+      return false
+    end
+  end
+
+  # delete a document from the index using the document id
+  def delete(document_id)
+    response = send(Solr::Request::Delete.new(:id => document_id))
+    commit if @autocommit
+    response.ok?
+  end
+
+  # delete using a query
+  def delete_by_query(query)
+    response = send(Solr::Request::Delete.new(:query => query))
+    commit if @autocommit
+    response.ok?
+  end
+  
+  def info
+    send(Solr::Request::IndexInfo.new)
+  end
+  
+  # send a given Solr::Request and return a RubyResponse or XmlResponse
+  # depending on the type of request
+  def send(request)
+    data = post(request)
+    Solr::Response::Base.make_response(request, data)
+  end
+
+  # send the http post request to solr; for convenience there are shortcuts
+  # to some requests: add(), query(), commit(), delete() or send()
+  def post(request)
+    response = @connection.post(@url.path + "/" + request.handler,
+                                request.to_s,
+                                { "Content-Type" => request.content_type })
+  
+    case response
+    when Net::HTTPSuccess then response.body
+    else
+      response.error!
+    end
+  
+  end
+  
+private
+  
+  def create_and_send_query(klass, options = {}, &action)
+    request = klass.new(options)
+    response = send(request)
+    return response unless action
+    response.each {|hit| action.call(hit)}
+  end
+  
+end
@@ -0,0 +1,78 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'solr/xml'
+require 'solr/field'
+
+class Solr::Document
+  include Enumerable
+  attr_accessor :boost
+  attr_reader :fields
+
+  # Create a new Solr::Document, optionally passing in a hash of 
+  # key/value pairs for the fields
+  #
+  #   doc = Solr::Document.new(:creator => 'Jorge Luis Borges')
+  def initialize(hash={})
+    @fields = []
+    self << hash
+  end
+
+  # Append a Solr::Field
+  #
+  #   doc << Solr::Field.new(:creator => 'Jorge Luis Borges')
+  #
+  # If you are truly lazy you can simply pass in a hash:
+  #
+  #   doc << {:creator => 'Jorge Luis Borges'}
+  def <<(fields)
+    case fields
+    when Hash
+      fields.each_pair do |name,value|
+        if value.respond_to?(:each) && !value.is_a?(String)
+          value.each {|v| @fields << Solr::Field.new(name => v)}
+        else
+          @fields << Solr::Field.new(name => value)
+        end
+      end
+    when Solr::Field
+      @fields << fields
+    else
+      raise "must pass in Solr::Field or Hash"
+    end
+  end
+
+  # shorthand to allow hash lookups
+  #   doc['name']
+  def [](name)
+    field = @fields.find {|f| f.name == name.to_s}
+    return field.value if field
+    return nil
+  end
+
+  # shorthand to assign as a hash
+  def []=(name,value)
+    @fields << Solr::Field.new(name => value)
+  end
+
+  # convert the Document to a REXML::Element 
+  def to_xml
+    e = Solr::XML::Element.new 'doc'
+    e.attributes['boost'] = @boost.to_s if @boost
+    @fields.each {|f| e.add_element(f.to_xml)}
+    return e
+  end
+
+  def each(*args, &blk)
+    fields.each(&blk)
+  end
+end
@@ -0,0 +1,13 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class Solr::Exception < Exception; end
@@ -0,0 +1,39 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'solr/xml'
+require 'time'
+
+class Solr::Field
+  VALID_PARAMS = [:boost]
+  attr_accessor :name
+  attr_accessor :value
+  attr_accessor :boost
+
+  # Accepts an optional <tt>:boost</tt> parameter, used to boost the relevance of a particular field.
+  def initialize(params)
+    @boost = params[:boost]
+    name_key = (params.keys - VALID_PARAMS).first
+    @name, @value = name_key.to_s, params[name_key]
+    # Convert any Time values into UTC/XML schema format (which Solr requires).
+    @value = @value.respond_to?(:utc) ? @value.utc.xmlschema : @value.to_s
+  end
+
+  def to_xml
+    e = Solr::XML::Element.new 'field'
+    e.attributes['name'] = @name
+    e.attributes['boost'] = @boost.to_s if @boost
+    e.text = @value
+    return e
+  end
+
+end
@@ -0,0 +1,19 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Solr; module Importer; end; end
+require 'solr/importer/mapper'
+require 'solr/importer/array_mapper'
+require 'solr/importer/delimited_file_source'
+require 'solr/importer/hpricot_mapper'
+require 'solr/importer/xpath_mapper'
+require 'solr/importer/solr_source'
 \ No newline at end of file
@@ -0,0 +1,26 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+
+
+class Solr::Importer::ArrayMapper < Solr::Importer::Mapper
+  # TODO document that initializer takes an array of Mappers [mapper1, mapper2, ... mapperN]
+  
+  # TODO: make merge conflict handling configurable.  as is, the last map fields win.
+  def map(orig_data_array)
+    mapped_data = {}
+    orig_data_array.each_with_index do |data,i|
+      mapped_data.merge!(@mapping[i].map(data))
+    end
+    mapped_data
+  end
+end
 \ No newline at end of file
@@ -0,0 +1,38 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# For files with the first line containing field names
+# Currently not designed for enormous files, as all lines are
+# read into an array
+class Solr::Importer::DelimitedFileSource
+  include Enumerable
+  
+  def initialize(filename, splitter=/\t/)
+    @filename = filename
+    @splitter = splitter
+  end
+
+  def each
+    lines = IO.readlines(@filename)
+    headers = lines[0].split(@splitter).collect{|h| h.chomp}
+    
+    lines[1..-1].each do |line|
+      data = headers.zip(line.split(@splitter).collect{|s| s.chomp})
+      def data.[](key)
+        self.assoc(key.to_s)[1]
+      end
+      
+      yield(data)
+    end
+  end
+  
+end
@@ -0,0 +1,27 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+begin
+  require 'hpricot'
+
+  class Solr::Importer::HpricotMapper < Solr::Importer::Mapper
+    def field_data(doc, path)
+      doc.search(path.to_s).collect { |e| e.inner_html }
+    end
+  end
+rescue LoadError => e # If we can't load hpricot
+  class Solr::Importer::HpricotMapper
+    def initialize(mapping, options={})
+      raise "Hpricot not installed."
+    end
+  end
+end
 \ No newline at end of file
@@ -0,0 +1,51 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class Solr::Importer::Mapper
+  def initialize(mapping, options={})
+    @mapping = mapping
+    @options = options
+  end
+  
+  def field_data(orig_data, field_name)
+    orig_data[field_name]
+  end
+  
+  def mapped_field_value(orig_data, field_mapping)
+    case field_mapping
+      when String
+        field_mapping
+      when Proc
+        field_mapping.call(orig_data)  # TODO pass in more context, like self or a function for field_data, etc
+      when Symbol
+        field_data(orig_data, @options[:stringify_symbols] ? field_mapping.to_s : field_mapping)
+      when Enumerable
+        field_mapping.collect {|orig_field_name| mapped_field_value(orig_data, orig_field_name)}.flatten
+      else
+        raise "Unknown mapping for #{field_mapping}"
+    end
+  end
+  
+  def map(orig_data)
+    mapped_data = {}
+    @mapping.each do |solr_name, field_mapping|
+      value = mapped_field_value(orig_data, field_mapping)
+      mapped_data[solr_name] = value if value
+    end
+    
+    mapped_data
+  end
+  
+  
+  
+  
+end
@@ -0,0 +1,43 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'solr'
+
+class Solr::Importer::SolrSource
+  def initialize(solr_url, query, filter_queries=nil, options={})
+    @connection = Solr::Connection.new(solr_url)
+    @query = query
+    @filter_queries = filter_queries
+
+    @page_size = options[:page_size] || 1000
+    @field_list = options[:field_list] || ["*"]
+  end
+  
+  def each
+    done = false
+    start = 0
+    until done do
+      # request N documents from a starting point
+      request = Solr::Request::Standard.new(:query => @query,
+                                            :rows => @page_size,
+                                            :start => start,
+                                            :field_list => @field_list,
+                                            :filter_queries => @filter_queries)
+      response = @connection.send(request)
+      response.each do |doc|
+        yield doc  # TODO: perhaps convert to HashWithIndifferentAccess.new(doc), so stringify_keys isn't necessary
+      end
+      done = start + @page_size >= response.total_hits
+      start = start + @page_size
+    end
+  end
+end
@@ -0,0 +1,35 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+begin
+  require 'xml/libxml'
+
+  # For files with the first line containing field names
+  class Solr::Importer::XPathMapper < Solr::Importer::Mapper
+    def field_data(doc, xpath)
+      doc.find(xpath.to_s).collect do |node|
+        case node
+          when XML::Attr
+            node.value
+          when XML::Node
+            node.content
+        end
+      end
+    end
+  end
+rescue LoadError => e # If we can't load libxml
+  class Solr::Importer::XPathMapper
+    def initialize(mapping, options={})
+      raise "libxml not installed"
+    end
+  end
+end
@@ -0,0 +1,52 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class Solr::Indexer
+  attr_reader :solr
+  
+  # TODO: document options!
+  def initialize(data_source, mapper_or_mapping, options={})
+    solr_url = options[:solr_url] || ENV["SOLR_URL"] || "http://localhost:8983/solr"
+    @solr = Solr::Connection.new(solr_url, options) #TODO - these options contain the solr_url and debug keys also, so tidy up what gets passed
+
+    @data_source = data_source
+    @mapper = mapper_or_mapping.is_a?(Hash) ? Solr::Importer::Mapper.new(mapper_or_mapping) : mapper_or_mapping
+
+    @buffer_docs = options[:buffer_docs]
+    @debug = options[:debug]
+  end
+
+  def index
+    buffer = []
+    @data_source.each do |record|
+      document = @mapper.map(record)
+      
+      # TODO: check arrity of block, if 3, pass counter as 3rd argument
+      yield(record, document) if block_given? # TODO check return of block, if not true then don't index, or perhaps if document.empty?
+      
+      buffer << document
+      
+      if !@buffer_docs || buffer.size == @buffer_docs
+        add_docs(buffer)
+        buffer.clear
+      end
+    end
+    add_docs(buffer) if !buffer.empty?
+    
+    @solr.commit unless @debug
+  end
+  
+  def add_docs(documents)
+    @solr.add(documents) unless @debug
+    puts documents.inspect if @debug
+  end
+end
@@ -0,0 +1,26 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Solr; module Request; end; end
+require 'solr/request/add_document'
+require 'solr/request/modify_document'
+require 'solr/request/base'
+require 'solr/request/commit'
+require 'solr/request/delete'
+require 'solr/request/ping'
+require 'solr/request/select'
+require 'solr/request/standard'
+require 'solr/request/spellcheck'
+require 'solr/request/dismax'
+require 'solr/request/update'
+require 'solr/request/index_info'
+require 'solr/request/optimize'
@@ -0,0 +1,63 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'solr/xml'
+require 'solr/request/base'
+require 'solr/document'
+require 'solr/request/update'
+
+class Solr::Request::AddDocument < Solr::Request::Update
+
+  # create the request, optionally passing in a Solr::Document
+  #
+  #   request = Solr::Request::AddDocument.new doc
+  #
+  # as a short cut you can pass in a Hash instead:
+  #
+  #   request = Solr::Request::AddDocument.new :creator => 'Jorge Luis Borges'
+  # 
+  # or an array, to add multiple documents at the same time:
+  # 
+  #   request = Solr::Request::AddDocument.new([doc1, doc2, doc3])
+    
+  def initialize(doc={})
+    @docs = []
+    if doc.is_a?(Array)
+      doc.each { |d| add_doc(d) }
+    else
+      add_doc(doc)
+    end
+  end
+
+  # returns the request as a string suitable for posting
+  
+  def to_s
+    e = Solr::XML::Element.new 'add'
+    for doc in @docs
+      e.add_element doc.to_xml
+    end
+    return e.to_s
+  end
+  
+  private
+  def add_doc(doc)
+    case doc
+    when Hash
+      @docs << Solr::Document.new(doc)
+    when Solr::Document
+      @docs << doc
+    else
+      raise "must pass in Solr::Document or Hash"
+    end
+  end
+  
+end
@@ -0,0 +1,36 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class Solr::Request::Base
+  
+  
+  #TODO : Add base support for the debugQuery flag, and such that the response provides debug output easily
+
+  # returns either :xml or :ruby depending on what the
+  # response type is for a given request
+  
+  def response_format
+    raise "unknown request type: #{self.class}"
+  end
+  
+  def content_type
+    'text/xml; charset=utf-8'
+  end
+
+  # returns the solr handler or url fragment that can 
+  # respond to this type of request
+  
+  def handler
+    raise "unknown request type: #{self.class}"
+  end
+
+end
@@ -0,0 +1,31 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'solr/xml'
+
+class Solr::Request::Commit < Solr::Request::Update
+
+  def initialize(options={})
+    @wait_searcher = options[:wait_searcher] || true
+    @wait_flush = options[:wait_flush] || true
+  end
+
+
+  def to_s
+    e = Solr::XML::Element.new('commit')
+    e.attributes['waitSearcher'] = @wait_searcher ? 'true' : 'false'
+    e.attributes['waitFlush'] = @wait_flush ? 'true' : 'false'
+    
+    e.to_s
+  end
+
+end
@@ -0,0 +1,50 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'solr/xml'
+
+class Solr::Request::Delete < Solr::Request::Update
+
+  # A delete request can be for a specific document id
+  #
+  #   request = Solr::Request::Delete.new(:id => 1234)
+  #
+  # or by query:
+  #
+  #   request = Solr::Request::Delete.new(:query =>
+  #
+  def initialize(options)
+    unless options.kind_of?(Hash) and (options[:id] or options[:query])
+      raise Solr::Exception.new("must pass in :id or :query")
+    end
+    if options[:id] and options[:query]
+      raise Solr::Exception.new("can't pass in both :id and :query")
+    end
+    @document_id = options[:id]
+    @query = options[:query]
+  end
+
+  def to_s
+    delete_element = Solr::XML::Element.new('delete')
+    if @document_id
+      id_element = Solr::XML::Element.new('id')
+      id_element.text = @document_id
+      delete_element.add_element(id_element)
+    elsif @query
+      query = Solr::XML::Element.new('query')
+      query.text = @query 
+      delete_element.add_element(query)
+    end
+    delete_element.to_s
+  end
+end
+
@@ -0,0 +1,46 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class Solr::Request::Dismax < Solr::Request::Standard
+
+  VALID_PARAMS.replace(VALID_PARAMS + [:tie_breaker, :query_fields, :minimum_match, :phrase_fields, :phrase_slop,
+                                       :boost_query, :boost_functions])
+
+  def initialize(params)
+    @alternate_query = params.delete(:alternate_query)
+    @sort_values = params.delete(:sort)
+    
+    super
+    
+    @query_type = "dismax"
+  end
+  
+  def to_hash
+    hash = super
+    hash[:tie] = @params[:tie_breaker]
+    hash[:mm]  = @params[:minimum_match]
+    hash[:qf]  = @params[:query_fields]
+    hash[:pf]  = @params[:phrase_fields]
+    hash[:ps]  = @params[:phrase_slop]
+    hash[:bq]  = @params[:boost_query]
+    hash[:bf]  = @params[:boost_functions]
+    hash["q.alt"] = @alternate_query
+    # FIXME: 2007-02-13 <coda.hale@gmail.com> --  This code is duplicated in
+    # Solr::Request::Standard. It should be refactored into a single location.
+    hash[:sort] = @sort_values.collect do |sort|
+      key = sort.keys[0]
+      "#{key.to_s} #{sort[key] == :descending ? 'desc' : 'asc'}"
+    end.join(',') if @sort_values
+    return hash
+  end
+
+end
 \ No newline at end of file
@@ -0,0 +1,22 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class Solr::Request::IndexInfo < Solr::Request::Select
+  
+  def handler
+    'admin/luke'
+  end
+  
+  def to_hash
+    {:numTerms => 0}.merge(super.to_hash)
+  end
+end
@@ -0,0 +1,51 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'solr/xml'
+require 'solr/request/base'
+require 'solr/document'
+require 'solr/request/update'
+
+class Solr::Request::ModifyDocument < Solr::Request::Update
+
+  # Example: ModifyDocument.new(:id => 10, :overwrite => {:field_name => "new value"})
+  def initialize(update_data)
+    modes = []
+    @doc = {}
+    [:overwrite, :append, :distinct, :increment, :delete].each do |mode|
+      field_data = update_data[mode]
+      if field_data
+        field_data.each do |field_name, field_value|
+          modes << "#{field_name}:#{mode.to_s.upcase}"
+          @doc[field_name] = field_value if field_value  # if value is nil, omit so it can be removed
+        end
+        update_data.delete mode
+      end
+    end
+    @mode = modes.join(",")
+    
+    # only one key should be left over, the id
+    @doc[update_data.keys[0].to_s] = update_data.values[0]
+  end
+
+  # returns the request as a string suitable for posting
+  def to_s
+    e = Solr::XML::Element.new 'add'
+    e.add_element(Solr::Document.new(@doc).to_xml)
+    return e.to_s
+  end
+  
+  def handler
+    "update?mode=#{@mode}"
+  end
+  
+end
@@ -0,0 +1,21 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'solr/xml'
+
+class Solr::Request::Optimize < Solr::Request::Update
+
+  def to_s
+    Solr::XML::Element.new('optimize').to_s
+  end
+
+end
 \ No newline at end of file
@@ -0,0 +1,36 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# TODO: Consider something lazy like this?
+# Solr::Request::Ping = Solr::Request.simple_request :format=>:xml, :handler=>'admin/ping'
+# class Solr::Request
+#   def self.simple_request(options)
+#     Class.new do 
+#       def response_format
+#         options[:format]
+#       end
+#       def handler
+#         options[:handler]
+#       end
+#     end
+#   end
+# end
+
+class Solr::Request::Ping < Solr::Request::Base
+  def response_format
+    :xml
+  end
+  
+  def handler
+    'admin/ping'
+  end
+end
@@ -0,0 +1,56 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'erb'
+
+# "Abstract" base class, only useful with subclasses that add parameters
+class Solr::Request::Select < Solr::Request::Base
+      
+  attr_reader :query_type
+  
+  def initialize(qt=nil, params={})
+    @query_type = qt
+    @select_params = params
+  end
+  
+  def response_format
+    :ruby
+  end
+  
+  def handler
+    'select'
+  end
+  
+  def content_type
+    'application/x-www-form-urlencoded; charset=utf-8'
+  end
+
+  def to_hash
+    return {:qt => query_type, :wt => 'ruby'}.merge(@select_params)
+  end
+  
+  def to_s
+    raw_params = self.to_hash
+
+    http_params = []
+    raw_params.each do |key,value|
+      if value.respond_to? :each
+        value.each { |v| http_params << "#{key}=#{ERB::Util::url_encode(v)}" unless v.nil?}
+      else
+        http_params << "#{key}=#{ERB::Util::url_encode(value)}" unless value.nil?
+      end
+    end
+
+    http_params.join("&")
+  end
+  
+end
@@ -0,0 +1,30 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class Solr::Request::Spellcheck < Solr::Request::Select
+
+  def initialize(params)
+    super('spellchecker')
+    @params = params
+  end
+  
+  def to_hash
+    hash = super
+    hash[:q] = @params[:query]
+    hash[:suggestionCount] = @params[:suggestion_count]
+    hash[:accuracy] = @params[:accuracy]
+    hash[:onlyMorePopular] = @params[:only_more_popular]
+    hash[:cmd] = @params[:command]
+    return hash
+  end
+
+end
 \ No newline at end of file
@@ -0,0 +1,402 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class Solr::Request::Standard < Solr::Request::Select
+
+  VALID_PARAMS = [:query, :sort, :default_field, :operator, :start, :rows, :shards, :date_facets,
+    :filter_queries, :field_list, :debug_query, :explain_other, :facets, :highlighting, :mlt]
+  
+  def initialize(params)
+    super('standard')
+    
+    raise "Invalid parameters: #{(params.keys - VALID_PARAMS).join(',')}" unless 
+      (params.keys - VALID_PARAMS).empty?
+    
+    raise ":query parameter required" unless params[:query]
+    
+    @params = params.dup
+    
+    # Validate operator
+    if params[:operator]
+      raise "Only :and/:or operators allowed" unless 
+        [:and, :or].include?(params[:operator])
+        
+      @params[:operator] = params[:operator].to_s.upcase
+    end
+
+    # Validate start, rows can be transformed to ints
+    @params[:start] = params[:start].to_i if params[:start]
+    @params[:rows] = params[:rows].to_i if params[:rows]
+    
+    @params[:field_list] ||= ["*","score"]
+    
+    @params[:shards] ||= []
+  end
+  
+  def to_hash
+    hash = {}
+    
+    # standard request param processing
+    sort = @params[:sort].collect do |sort|
+      key = sort.keys[0]
+      "#{key.to_s} #{sort[key] == :descending ? 'desc' : 'asc'}"
+    end.join(',') if @params[:sort]
+    hash[:q] = sort ? "#{@params[:query]};#{sort}" : @params[:query]
+    hash["q.op"] = @params[:operator]
+    hash[:df] = @params[:default_field]
+
+    # common parameter processing
+    hash[:start] = @params[:start]
+    hash[:rows] = @params[:rows]
+    hash[:fq] = @params[:filter_queries]
+    hash[:fl] = @params[:field_list].join(',')
+    hash[:debugQuery] = @params[:debug_query]
+    hash[:explainOther] = @params[:explain_other]
+    hash[:shards] = @params[:shards].join(',') unless @params[:shards].empty?
+    
+    # facet parameter processing
+    if @params[:facets]
+      # TODO need validation of all that is under the :facets Hash too
+      hash[:facet] = true
+      hash["facet.field"] = []
+      hash["facet.query"] = @params[:facets][:queries]
+      hash["facet.sort"] = (@params[:facets][:sort] == :count) if @params[:facets][:sort]
+      hash["facet.limit"] = @params[:facets][:limit]
+      hash["facet.missing"] = @params[:facets][:missing]
+      hash["facet.mincount"] = @params[:facets][:mincount]
+      hash["facet.prefix"] = @params[:facets][:prefix]
+      hash["facet.offset"] = @params[:facets][:offset]
+      if @params[:facets][:fields]  # facet fields are optional (could be facet.query only)
+        @params[:facets][:fields].each do |f|
+          if f.kind_of? Hash
+            key = f.keys[0]
+            value = f[key]
+            hash["facet.field"] << key
+            hash["f.#{key}.facet.sort"] = (value[:sort] == :count) if value[:sort]
+            hash["f.#{key}.facet.limit"] = value[:limit]
+            hash["f.#{key}.facet.missing"] = value[:missing]
+            hash["f.#{key}.facet.mincount"] = value[:mincount]
+            hash["f.#{key}.facet.prefix"] = value[:prefix]
+            hash["f.#{key}.facet.offset"] = value[:offset]
+          else
+            hash["facet.field"] << f
+          end
+        end
+      end
+      
+      if @params[:date_facets]
+        hash["facet.date"] = []
+        if @params[:date_facets][:fields]
+          @params[:date_facets][:fields].each do |f|
+            if f.kind_of? Hash
+              key = f.keys[0]
+              hash["facet.date"] << key
+              f[key].each { |k, v|
+                hash["f.#{key}.facet.date.#{k}"] = v
+              }
+            else
+              hash["facet.date"] << f
+            end
+          end
+        end
+        hash["facet.date.start"] = @params[:date_facets][:start]
+        hash["facet.date.end"] = @params[:date_facets][:end]
+        hash["facet.date.gap"] = @params[:date_facets][:gap]
+        hash["facet.date.other"] = @params[:date_facets][:other]
+        hash["facet.date.hardend"] = @params[:date_facets][:hardend]
+        if @params[:date_facets][:filter]
+          if hash[:fq]
+            hash[:fq] << @params[:date_facets][:filter]
+          else
+            hash[:fq] = @params[:date_facets][:filter]
+          end
+        end
+      end
+    end
+    
+    # highlighting parameter processing - http://wiki.apache.org/solr/HighlightingParameters
+    if @params[:highlighting]
+      hash[:hl] = true
+      hash["hl.fl"] = @params[:highlighting][:field_list].join(',') if @params[:highlighting][:field_list]
+
+      snippets = @params[:highlighting][:max_snippets]
+      if snippets
+        if snippets.kind_of? Hash
+          if snippets[:default]
+            hash["hl.snippets"] = snippets[:default]
+          end
+          if snippets[:fields]
+            snippets[:fields].each do |k,v|
+              hash["f.#{k}.hl.snippets"] = v
+            end
+          end
+        else
+          hash["hl.snippets"] = snippets
+        end
+      end
+
+      fragsize = @params[:highlighting][:fragment_size]
+      if fragsize
+        if fragsize.kind_of? Hash
+          if fragsize[:default]
+            hash["hl.fragsize"] = fragsize[:default]
+          end
+          if fragsize[:fields]
+            fragsize[:fields].each do |k,v|
+              hash["f.#{k}.hl.fragsize"] = v
+            end
+          end
+        else
+          hash["hl.fragsize"] = fragsize
+        end
+      end
+
+      rfm = @params[:highlighting][:require_field_match]
+      if nil != rfm
+        if rfm.kind_of? Hash
+          if nil != rfm[:default]
+            hash["hl.requireFieldMatch"] = rfm[:default]
+          end
+          if rfm[:fields]
+            rfm[:fields].each do |k,v|
+              hash["f.#{k}.hl.requireFieldMatch"] = v
+            end
+          end
+        else
+          hash["hl.requireFieldMatch"] = rfm
+        end
+      end
+
+      mac = @params[:highlighting][:max_analyzed_chars]
+      if mac
+        if mac.kind_of? Hash
+          if mac[:default]
+            hash["hl.maxAnalyzedChars"] = mac[:default]
+          end
+          if mac[:fields]
+            mac[:fields].each do |k,v|
+              hash["f.#{k}.hl.maxAnalyzedChars"] = v
+            end
+          end
+        else
+          hash["hl.maxAnalyzedChars"] = mac
+        end
+      end
+
+      prefix = @params[:highlighting][:prefix]
+      if prefix
+        if prefix.kind_of? Hash
+          if prefix[:default]
+            hash["hl.simple.pre"] = prefix[:default]
+          end
+          if prefix[:fields]
+            prefix[:fields].each do |k,v|
+              hash["f.#{k}.hl.simple.pre"] = v
+            end
+          end
+        else
+          hash["hl.simple.pre"] = prefix
+        end
+      end
+
+      suffix = @params[:highlighting][:suffix]
+      if suffix
+        if suffix.kind_of? Hash
+          if suffix[:default]
+            hash["hl.simple.post"] = suffix[:default]
+          end
+          if suffix[:fields]
+            suffix[:fields].each do |k,v|
+              hash["f.#{k}.hl.simple.post"] = v
+            end
+          end
+        else
+          hash["hl.simple.post"] = suffix
+        end
+      end
+
+      formatter = @params[:highlighting][:formatter]
+      if formatter
+        if formatter.kind_of? Hash
+          if formatter[:default]
+            hash["hl.formatter"] = formatter[:default]
+          end
+          if formatter[:fields]
+            formatter[:fields].each do |k,v|
+              hash["f.#{k}.hl.formatter"] = v
+            end
+          end
+        else
+          hash["hl.formatter"] = formatter
+        end
+      end
+
+      fragmenter = @params[:highlighting][:fragmenter]
+      if fragmenter
+        if fragmenter.kind_of? Hash
+          if fragmenter[:default]
+            hash["hl.fragmenter"] = fragmenter[:default]
+          end
+          if fragmenter[:fields]
+            fragmenter[:fields].each do |k,v|
+              hash["f.#{k}.hl.fragmenter"] = v
+            end
+          end
+        else
+          hash["hl.fragmenter"] = fragmenter
+        end
+      end
+
+      merge_contiguous = @params[:highlighting][:merge_contiguous]
+      if nil != merge_contiguous
+        if merge_contiguous.kind_of? Hash
+          if nil != merge_contiguous[:default]
+            hash["hl.mergeContiguous"] = merge_contiguous[:default]
+          end
+          if merge_contiguous[:fields]
+            merge_contiguous[:fields].each do |k,v|
+              hash["f.#{k}.hl.mergeContiguous"] = v
+            end
+          end
+        else
+          hash["hl.mergeContiguous"] = merge_contiguous
+        end
+      end
+
+      increment = @params[:highlighting][:increment]
+      if increment
+        if increment.kind_of? Hash
+          if increment[:default]
+            hash["hl.increment"] = increment[:default]
+          end
+          if increment[:fields]
+            increment[:fields].each do |k,v|
+              hash["f.#{k}.hl.increment"] = v
+            end
+          end
+        else
+          hash["hl.increment"] = increment
+        end
+      end
+
+      # support "old style"
+      alternate_fields = @params[:highlighting][:alternate_fields]
+      if alternate_fields
+        alternate_fields.each do |f,v|
+          hash["f.#{f}.hl.alternateField"] = v
+        end
+      end
+
+      alternate_field = @params[:highlighting][:alternate_field]
+      if alternate_field
+        if alternate_field.kind_of? Hash
+          if alternate_field[:default]
+            hash["hl.alternateField"] = alternate_field[:default]
+          end
+          if alternate_field[:fields]
+            alternate_field[:fields].each do |k,v|
+              hash["f.#{k}.hl.alternateField"] = v
+            end
+          end
+        else
+          hash["hl.alternateField"] = alternate_field
+        end
+      end
+
+      mafl = @params[:highlighting][:max_alternate_field_length]
+      if mafl
+        if mafl.kind_of? Hash
+          if mafl[:default]
+            hash["hl.maxAlternateFieldLength"] = mafl[:default]
+          end
+          if mafl[:fields]
+            mafl[:fields].each do |k,v|
+              hash["f.#{k}.hl.maxAlternateFieldLength"] = v
+            end
+          else
+            # support "old style"
+            mafl.each do |k,v|
+              hash["f.#{k}.hl.maxAlternateFieldLength"] = v
+            end
+          end
+        else
+          hash["hl.maxAlternateFieldLength"] = mafl
+        end
+      end
+
+      hash["hl.usePhraseHighlighter"] = @params[:highlighting][:use_phrase_highlighter]
+
+      regex = @params[:highlighting][:regex]
+      if regex
+        if regex[:slop]
+          if regex[:slop].kind_of? Hash
+            if regex[:slop][:default]
+              hash["hl.regex.slop"] = regex[:slop][:default]
+            end
+            if regex[:slop][:fields]
+              regex[:slop][:fields].each do |k,v|
+                hash["f.#{k}.hl.regex.slop"] = v
+              end
+            end
+          else
+            hash["hl.regex.slop"] = regex[:slop]
+          end
+        end
+        if regex[:pattern]
+          if regex[:pattern].kind_of? Hash
+            if regex[:pattern][:default]
+              hash["hl.regex.pattern"] = regex[:pattern][:default]
+            end
+            if regex[:pattern][:fields]
+              regex[:pattern][:fields].each do |k,v|
+                hash["f.#{k}.hl.regex.pattern"] = v
+              end
+            end
+          else
+            hash["hl.regex.pattern"] = regex[:pattern]
+          end
+        end
+        if regex[:max_analyzed_chars]
+          if regex[:max_analyzed_chars].kind_of? Hash
+            if regex[:max_analyzed_chars][:default]
+              hash["hl.regex.maxAnalyzedChars"] = regex[:max_analyzed_chars][:default]
+            end
+            if regex[:max_analyzed_chars][:fields]
+              regex[:max_analyzed_chars][:fields].each do |k,v|
+                hash["f.#{k}.hl.regex.maxAnalyzedChars"] = v
+              end
+            end
+          else
+            hash["hl.regex.maxAnalyzedChars"] = regex[:max_analyzed_chars]
+          end
+        end
+      end
+
+    end
+    
+    if @params[:mlt]
+      hash[:mlt] = true
+      hash["mlt.count"] = @params[:mlt][:count]
+      hash["mlt.fl"] = @params[:mlt][:field_list].join(',')
+      hash["mlt.mintf"] = @params[:mlt][:min_term_freq]
+      hash["mlt.mindf"] = @params[:mlt][:min_doc_freq]
+      hash["mlt.minwl"] = @params[:mlt][:min_word_length]
+      hash["mlt.maxwl"] = @params[:mlt][:max_word_length]
+      hash["mlt.maxqt"] = @params[:mlt][:max_query_terms]
+      hash["mlt.maxntp"] = @params[:mlt][:max_tokens_parsed]
+      hash["mlt.boost"] = @params[:mlt][:boost]
+    end
+    
+    hash.merge(super.to_hash)
+  end
+
+end
@@ -0,0 +1,23 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# a parent class for all requests that go through the solr update handler
+# TODO: Use new xml update handler for better error responses
+class Solr::Request::Update < Solr::Request::Base
+  def response_format
+    :xml
+  end
+
+  def handler
+    'update'
+  end
+end
@@ -0,0 +1,27 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Solr; module Response; end; end
+require 'solr/response/base'
+require 'solr/response/xml'
+require 'solr/response/ruby'
+require 'solr/response/ping'
+require 'solr/response/add_document'
+require 'solr/response/modify_document'
+require 'solr/response/standard'
+require 'solr/response/spellcheck'
+require 'solr/response/dismax'
+require 'solr/response/commit'
+require 'solr/response/delete'
+require 'solr/response/index_info'
+require 'solr/response/optimize'
+require 'solr/response/select'
 \ No newline at end of file
@@ -0,0 +1,17 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class Solr::Response::AddDocument < Solr::Response::Xml
+  def initialize(xml)
+    super
+  end
+end
@@ -0,0 +1,42 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class Solr::Response::Base
+  attr_reader :raw_response
+
+  def initialize(raw_response)
+    @raw_response = raw_response
+  end
+
+  # factory method for creating a Solr::Response::* from 
+  # a request and the raw response content
+  def self.make_response(request, raw)
+
+    # make sure response format seems sane
+    unless [:xml, :ruby].include?(request.response_format)
+      raise Solr::Exception.new("unknown response format: #{request.response_format}" )
+    end
+
+    # TODO: Factor out this case... perhaps the request object should provide the response class instead?  Or dynamically align by class name?
+    #       Maybe the request itself could have the response handling features that get mixed in with a single general purpose response object?
+    
+    begin
+      klass = eval(request.class.name.sub(/Request/,'Response'))
+    rescue NameError
+      raise Solr::Exception.new("unknown request type: #{request.class}")
+    else
+      klass.new(raw)
+    end
+    
+  end
+
+end
@@ -0,0 +1,17 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'rexml/xpath'
+
+class Solr::Response::Commit < Solr::Response::Xml
+end
+
@@ -0,0 +1,13 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class Solr::Response::Delete < Solr::Response::Xml; end
@@ -0,0 +1,8 @@
+class Solr::Response::Dismax < Solr::Response::Standard
+  # no need for special processing
+  
+  # FIXME: 2007-02-07 <coda.hale@gmail.com> --  The existence of this class indicates that
+  # the Request/Response pair architecture is a little hinky. Perhaps we could refactor
+  # out some of the most common functionality -- Common Query Parameters, Highlighting Parameters,
+  # Simple Facet Parameters, etc. -- into modules?
+end
 \ No newline at end of file
@@ -0,0 +1,26 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class Solr::Response::IndexInfo < Solr::Response::Ruby
+  def initialize(ruby_code)
+    super
+  end
+
+  def num_docs
+    return @data['index']['numDocs']
+  end
+  
+  def field_names
+    return @data['fields'].keys
+  end
+
+end
@@ -0,0 +1,17 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class Solr::Response::ModifyDocument < Solr::Response::Xml
+  def initialize(xml)
+    super
+  end
+end
@@ -0,0 +1,14 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class Solr::Response::Optimize < Solr::Response::Commit
+end
 \ No newline at end of file
@@ -0,0 +1,28 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'rexml/xpath'
+
+class Solr::Response::Ping < Solr::Response::Xml
+
+  def initialize(xml)
+    super
+    @ok = REXML::XPath.first(@doc, './solr/ping') ? true : false
+  end
+
+  # returns true or false depending on whether the ping
+  # was successful or not
+  def ok?
+    @ok
+  end
+
+end
@@ -0,0 +1,42 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class Solr::Response::Ruby < Solr::Response::Base
+  attr_reader :data, :header
+
+  def initialize(ruby_code)
+    super
+    begin
+      #TODO: what about pulling up data/header/response to ResponseBase,
+      #      or maybe a new middle class like SelectResponseBase since
+      #      all Select queries return this same sort of stuff??
+      #      XML (&wt=xml) and Ruby (&wt=ruby) responses contain exactly the same structure.
+      #      a goal of solrb is to make it irrelevant which gets used under the hood, 
+      #      but favor Ruby responses.
+      @data = eval(ruby_code)
+      @header = @data['responseHeader']
+      raise "response should be a hash" unless @data.kind_of? Hash
+      raise "response header missing" unless @header.kind_of? Hash
+    rescue SyntaxError => e
+      raise Solr::Exception.new("invalid ruby code: #{e}")
+    end
+  end
+
+  def ok?
+    @header['status'] == 0
+  end
+
+  def query_time
+    @header['QTime']
+  end
+  
+end
@@ -0,0 +1,17 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class Solr::Response::Select < Solr::Response::Ruby
+  def initialize(ruby_code)
+    super
+  end
+end
@@ -0,0 +1,20 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class Solr::Response::Spellcheck < Solr::Response::Ruby
+  attr_reader :suggestions
+  
+  def initialize(ruby_code)
+    super
+    @suggestions = @data['suggestions']
+  end
+end
@@ -0,0 +1,60 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class Solr::Response::Standard < Solr::Response::Ruby
+  FacetValue = Struct.new(:name, :value)
+  include Enumerable
+  
+  def initialize(ruby_code)
+    super
+    @response = @data['response']
+    raise "response section missing" unless @response.kind_of? Hash
+  end
+
+  def total_hits
+    @response['numFound']
+  end
+
+  def start
+    @response['start']
+  end
+
+  def hits
+    @response['docs']
+  end
+
+  def max_score
+    @response['maxScore']
+  end
+  
+  # TODO: consider the use of json.nl parameter
+  def field_facets(field)
+    facets = []
+    values = @data['facet_counts']['facet_fields'][field]
+    Solr::Util.paired_array_each(values) do |key, value|
+      facets << FacetValue.new(key, value)
+    end
+    
+    facets
+  end
+  
+  def highlighted(id, field)
+    @data['highlighting'][id.to_s][field.to_s] rescue nil
+  end
+  
+  # supports enumeration of hits
+  # TODO revisit - should this iterate through *all* hits by re-requesting more?
+  def each
+    @response['docs'].each {|hit| yield hit}
+  end
+
+end
@@ -0,0 +1,42 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+require 'rexml/document'
+require 'solr/exception'
+
+class Solr::Response::Xml < Solr::Response::Base
+  attr_reader :doc, :status_code, :status_message
+
+  def initialize(xml)
+    super
+    # parse the xml
+    @doc = REXML::Document.new(xml)
+
+    # look for the result code and string 
+    # <?xml version="1.0" encoding="UTF-8"?>
+    # <response>
+    # <lst name="responseHeader"><int name="status">0</int><int name="QTime">2</int></lst>
+    # </response>
+    result = REXML::XPath.first(@doc, './response/lst[@name="responseHeader"]/int[@name="status"]')
+    if result
+      @status_code =  result.text
+      @status_message = result.text  # TODO: any need for a message?
+    end
+  rescue REXML::ParseException => e
+    raise Solr::Exception.new("invalid response xml: #{e}")
+  end
+
+  def ok?
+    return @status_code == '0'
+  end
+
+end
@@ -0,0 +1,27 @@
+#!/usr/bin/env ruby
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# TODO: fill out Solr tasks: start, stop, ping, optimize, etc.
+
+require 'rake'
+require 'rake/tasklib'
+
+module Solr
+  namespace :solr do
+    desc "Start Solr"
+    task :start do
+      # TODO: actually start it up!
+      puts "Starting..."
+    end
+  end
+end
@@ -0,0 +1,32 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+class Solr::Util
+  # paired_array_each([key1,value1,key2,value2]) yields twice:
+  #     |key1,value1|  and |key2,value2|
+  def self.paired_array_each(a, &block)
+    0.upto(a.size / 2 - 1) do |i|
+      n = i * 2
+      yield(a[n], a[n+1])
+    end
+  end
+
+  # paired_array_to_hash([key1,value1,key2,value2]) => {key1 => value1, key2, value2}
+  def self.paired_array_to_hash(a)
+    Hash[*a]
+  end
+  
+  def self.query_parser_escape(string)
+    # backslash prefix everything that isn't a word character
+    string.gsub(/(\W)/,'\\\\\1')
+  end
+end
@@ -0,0 +1,44 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+module Solr::XML
+end
+
+begin
+  
+  # If we can load rubygems and libxml-ruby...
+  require 'rubygems'
+  require 'xml/libxml'
+  raise "acts_as_solr requires libxml-ruby 0.7 or greater" unless XML::Node.public_instance_methods.include?("attributes")
+
+  # then make a few modifications to XML::Node so it can stand in for REXML::Element
+  class XML::Node
+    # element.add_element(another_element) should work
+    alias_method :add_element, :<<
+
+
+    # element.text = "blah" should work
+    def text=(x)
+      self << x.to_s
+    end
+  end
+  
+  # And use XML::Node for our XML generation
+  Solr::XML::Element = XML::Node
+  
+rescue LoadError => e # If we can't load either rubygems or libxml-ruby
+  puts "Requiring REXML"
+  # Just use REXML.
+  require 'rexml/document'
+  Solr::XML::Element = REXML::Element
+  
+end
 \ No newline at end of file
@@ -0,0 +1,13 @@
+module ActsAsSolr
+
+  class SolrFixtures
+    def self.load(table_names)
+      [table_names].flatten.map { |n| n.to_s }.each do |table_name|
+        klass = instance_eval(File.split(table_name.to_s).last.to_s.gsub('_',' ').split(" ").collect{|w| w.capitalize}.to_s.singularize)
+        klass.rebuild_solr_index if klass.respond_to?(:rebuild_solr_index)
+      end
+      ActsAsSolr::Post.execute(Solr::Request::Commit.new)
+    end
+  end
+  
+end
 \ No newline at end of file
@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + '/../solr_fixtures'
+
+namespace :db do
+  namespace :fixtures do
+    desc "Load fixtures into the current environment's database. Load specific fixtures using FIXTURES=x,y"
+    task :load => :environment do
+      begin
+        ActsAsSolr::Post.execute(Solr::Request::Delete.new(:query => "*:*"))
+        ActsAsSolr::Post.execute(Solr::Request::Commit.new)
+        (ENV['FIXTURES'] ? ENV['FIXTURES'].split(/,/) : Dir.glob(File.join(RAILS_ROOT, 'test', 'fixtures', '*.{yml,csv}'))).each do |fixture_file|    
+          ActsAsSolr::SolrFixtures.load(File.basename(fixture_file, '.*'))
+        end 
+        puts "The fixtures loaded have been added to Solr"       
+      rescue
+      end
+    end
+  end
+end
 \ No newline at end of file
@@ -0,0 +1,137 @@
+require 'rubygems'
+require 'rake'
+require 'net/http'
+require 'active_record'
+
+namespace :solr do
+
+  desc 'Starts Solr. Options accepted: RAILS_ENV=your_env, PORT=XX. Defaults to development if none.'
+  task :start do
+    require "#{File.dirname(__FILE__)}/../../config/solr_environment.rb"
+    begin
+      n = Net::HTTP.new('127.0.0.1', SOLR_PORT)
+      n.request_head('/').value 
+
+    rescue Net::HTTPServerException #responding
+      puts "Port #{SOLR_PORT} in use" and return
+
+    rescue Errno::ECONNREFUSED #not responding
+      Dir.chdir(SOLR_PATH) do
+        pid = fork do
+          #STDERR.close
+          exec "java #{SOLR_JVM_OPTIONS} -Dsolr.data.dir=#{SOLR_DATA_PATH} -Djetty.logs=#{SOLR_LOGS_PATH} -Djetty.port=#{SOLR_PORT} -jar start.jar"
+        end
+        sleep(5)
+        File.open("#{SOLR_PIDS_PATH}/#{ENV['RAILS_ENV']}_pid", "w"){ |f| f << pid}
+        puts "#{ENV['RAILS_ENV']} Solr started successfully on #{SOLR_PORT}, pid: #{pid}."
+      end
+    end
+  end
+  
+  desc 'Stops Solr. Specify the environment by using: RAILS_ENV=your_env. Defaults to development if none.'
+  task :stop do
+    require "#{File.dirname(__FILE__)}/../../config/solr_environment.rb"
+    fork do
+      file_path = "#{SOLR_PIDS_PATH}/#{ENV['RAILS_ENV']}_pid"
+      if File.exists?(file_path)
+        File.open(file_path, "r") do |f| 
+          pid = f.readline
+          Process.kill('TERM', pid.to_i)
+        end
+        File.unlink(file_path)
+        Rake::Task["solr:destroy_index"].invoke if ENV['RAILS_ENV'] == 'test'
+        puts "Solr shutdown successfully."
+      else
+        puts "PID file not found at #{file_path}. Either Solr is not running or no PID file was written."
+      end
+    end
+  end
+  
+  desc 'Remove Solr index'
+  task :destroy_index do
+    require "#{File.dirname(__FILE__)}/../../config/solr_environment.rb"
+    raise "In production mode.  I'm not going to delete the index, sorry." if ENV['RAILS_ENV'] == "production"
+    if File.exists?("#{SOLR_DATA_PATH}")
+      Dir["#{SOLR_DATA_PATH}/index/*"].each{|f| File.unlink(f)}
+      Dir.rmdir("#{SOLR_DATA_PATH}/index")
+      puts "Index files removed under " + ENV['RAILS_ENV'] + " environment"
+    end
+  end
+  
+  # this task is by Henrik Nyh
+  # http://henrik.nyh.se/2007/06/rake-task-to-reindex-models-for-acts_as_solr
+  desc %{Reindexes data for all acts_as_solr models. Clears index first to get rid of orphaned records and optimizes index afterwards. RAILS_ENV=your_env to set environment. ONLY=book,person,magazine to only reindex those models; EXCEPT=book,magazine to exclude those models. START_SERVER=true to solr:start before and solr:stop after. BATCH=123 to post/commit in batches of that size: default is 300. CLEAR=false to not clear the index first; OPTIMIZE=false to not optimize the index afterwards.}
+  task :reindex => :environment do
+    require "#{File.dirname(__FILE__)}/../../config/solr_environment.rb"
+
+    includes = env_array_to_constants('ONLY')
+    if includes.empty?
+      includes = Dir.glob("#{RAILS_ROOT}/app/models/*.rb").map { |path| File.basename(path, ".rb").camelize.constantize }
+    end
+    excludes = env_array_to_constants('EXCEPT')
+    includes -= excludes
+    
+    optimize            = env_to_bool('OPTIMIZE',     true)
+    start_server        = env_to_bool('START_SERVER', false)
+    clear_first         = env_to_bool('CLEAR',       true)
+    batch_size          = ENV['BATCH'].to_i.nonzero? || 300
+    debug_output        = env_to_bool("DEBUG", false)
+
+    RAILS_DEFAULT_LOGGER.level = ActiveSupport::BufferedLogger::INFO unless debug_output
+
+    if start_server
+      puts "Starting Solr server..."
+      Rake::Task["solr:start"].invoke 
+    end
+    
+    # Disable solr_optimize
+    module ActsAsSolr::CommonMethods
+      def blank() end
+      alias_method :deferred_solr_optimize, :solr_optimize
+      alias_method :solr_optimize, :blank
+    end
+    
+    models = includes.select { |m| m.respond_to?(:rebuild_solr_index) }    
+    models.each do |model|
+  
+      if clear_first
+        puts "Clearing index for #{model}..."
+        ActsAsSolr::Post.execute(Solr::Request::Delete.new(:query => "#{model.solr_configuration[:type_field]}:#{model}")) 
+        ActsAsSolr::Post.execute(Solr::Request::Commit.new)
+      end
+      
+      puts "Rebuilding index for #{model}..."
+      model.rebuild_solr_index(batch_size)
+
+    end 
+
+    if models.empty?
+      puts "There were no models to reindex."
+    elsif optimize
+      puts "Optimizing..."
+      models.last.deferred_solr_optimize
+    end
+
+    if start_server
+      puts "Shutting down Solr server..."
+      Rake::Task["solr:stop"].invoke 
+    end
+    
+  end
+  
+  def env_array_to_constants(env)
+    env = ENV[env] || ''
+    env.split(/\s*,\s*/).map { |m| m.singularize.camelize.constantize }.uniq
+  end
+  
+  def env_to_bool(env, default)
+    env = ENV[env] || ''
+    case env
+      when /^true$/i then true
+      when /^false$/i then false
+      else default
+    end
+  end
+
+end
+
@@ -0,0 +1,7 @@
+require 'active_record'
+
+namespace :test do
+  task :migrate do
+    ActiveRecord::Migrator.migrate("test/db/migrate/", ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
+  end
+end
@@ -0,0 +1,31 @@
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements.  See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+
+<!-- The content of this page will be statically included into the top
+of the admin page.  Uncomment this as an example to see there the content
+will show up.
+
+<hr>
+<i>This line will appear before the first table</i>
+<tr>
+<td colspan="2">
+This row will be appended to the end of the first table
+</td>
+</tr>
+<hr>
+
+-->
@@ -0,0 +1,21 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+#-----------------------------------------------------------------------
+# Use a protected word file to protect against the stemmer reducing two
+# unrelated words to the same base word.
+
+# Some non-words that normally won't be encountered,
+# just to test that they won't be stemmed.
+dontstems
+zwhacky
+
@@ -0,0 +1,126 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements.  See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+
+<!--  
+ This is the Solr schema file. This file should be named "schema.xml" and
+ should be in the conf directory under the solr home
+ (i.e. ./solr/conf/schema.xml by default) 
+ or located where the classloader for the Solr webapp can find it.
+
+ This example schema is the recommended starting point for users.
+ It should be kept correct and concise, usable out-of-the-box.
+
+ For more information, on how to customize this file, please see
+ http://wiki.apache.org/solr/SchemaXml
+-->
+
+<schema name="acts_as_solr" version="0.9">
+  <types>
+    <fieldType name="string" class="solr.StrField" sortMissingLast="true" omitNorms="false"/>
+    <fieldType name="boolean" class="solr.BoolField" sortMissingLast="true" omitNorms="false"/>
+    <fieldType name="integer" class="solr.IntField" omitNorms="false"/>
+    <fieldType name="long" class="solr.LongField" omitNorms="false"/>
+    <fieldType name="float" class="solr.FloatField" omitNorms="false"/>
+    <fieldType name="double" class="solr.DoubleField" omitNorms="false"/>
+    <fieldType name="sint" class="solr.SortableIntField" sortMissingLast="true" omitNorms="false"/>
+    <fieldType name="slong" class="solr.SortableLongField" sortMissingLast="true" omitNorms="false"/>
+    <fieldType name="sfloat" class="solr.SortableFloatField" sortMissingLast="true" omitNorms="false"/>
+    <fieldType name="sdouble" class="solr.SortableDoubleField" sortMissingLast="true" omitNorms="false"/>
+    <fieldType name="date" class="solr.DateField" sortMissingLast="true" omitNorms="false"/>
+    <fieldType name="text_ws" class="solr.TextField" positionIncrementGap="100">
+      <analyzer>
+        <tokenizer class="solr.WhitespaceTokenizerFactory"/>
+      </analyzer>
+    </fieldType>
+
+    <fieldType name="text" class="solr.TextField" positionIncrementGap="100">
+      <analyzer type="index">
+        <tokenizer class="solr.WhitespaceTokenizerFactory"/>
+        <filter class="solr.StopFilterFactory" ignoreCase="true" words="stopwords.txt"/>
+        <filter class="solr.WordDelimiterFilterFactory" generateWordParts="1" generateNumberParts="1" catenateWords="1" catenateNumbers="1" catenateAll="0"/>
+        <filter class="solr.LowerCaseFilterFactory"/>
+        <filter class="solr.EnglishPorterFilterFactory" protected="protwords.txt"/>
+        <filter class="solr.RemoveDuplicatesTokenFilterFactory"/>
+      </analyzer>
+      <analyzer type="query">
+        <tokenizer class="solr.WhitespaceTokenizerFactory"/>
+        <filter class="solr.SynonymFilterFactory" synonyms="synonyms.txt" ignoreCase="true" expand="true"/>
+        <filter class="solr.StopFilterFactory" ignoreCase="true" words="stopwords.txt"/>
+        <filter class="solr.WordDelimiterFilterFactory" generateWordParts="1" generateNumberParts="1" catenateWords="0" catenateNumbers="0" catenateAll="0"/>
+        <filter class="solr.LowerCaseFilterFactory"/>
+        <filter class="solr.EnglishPorterFilterFactory" protected="protwords.txt"/>
+        <filter class="solr.RemoveDuplicatesTokenFilterFactory"/>
+      </analyzer>
+    </fieldType>
+
+    <fieldType name="textTight" class="solr.TextField" positionIncrementGap="100" >
+      <analyzer>
+        <tokenizer class="solr.WhitespaceTokenizerFactory"/>
+        <filter class="solr.SynonymFilterFactory" synonyms="synonyms.txt" ignoreCase="true" expand="false"/>
+        <filter class="solr.StopFilterFactory" ignoreCase="true" words="stopwords.txt"/>
+        <filter class="solr.WordDelimiterFilterFactory" generateWordParts="0" generateNumberParts="0" catenateWords="1" catenateNumbers="1" catenateAll="0"/>
+        <filter class="solr.LowerCaseFilterFactory"/>
+        <filter class="solr.EnglishPorterFilterFactory" protected="protwords.txt"/>
+        <filter class="solr.RemoveDuplicatesTokenFilterFactory"/>
+      </analyzer>
+    </fieldType>
+
+    <fieldType name="alphaOnlySort" class="solr.TextField" sortMissingLast="true" omitNorms="false">
+      <analyzer>
+        <tokenizer class="solr.KeywordTokenizerFactory"/>
+        <filter class="solr.LowerCaseFilterFactory" />
+        <filter class="solr.TrimFilterFactory" />
+        <filter class="solr.PatternReplaceFilterFactory" pattern="([^a-z])" replacement="" replace="all"/>
+      </analyzer>
+    </fieldType>
+
+    <fieldtype name="text_zh" class="solr.TextField">
+      <analyzer class="org.apache.lucene.analysis.cn.ChineseAnalyzer"/>
+    </fieldtype>
+
+ </types>
+
+
+ <fields>
+   <field name="id" type="string" indexed="true" stored="true" required="true" /> 
+   <field name="pk_i" type="integer" indexed="true" stored="true"/>
+   <field name="pk_s" type="string" indexed="true" stored="true"/>   
+   <field name="text" type="text" indexed="true" stored="false" multiValued="true"/>
+
+   <dynamicField name="*_i" type="integer" indexed="true" stored="false"/>
+   <dynamicField name="*_t" type="text" indexed="true" stored="false"/>
+   <dynamicField name="*_f" type="float" indexed="true" stored="false"/>
+   <dynamicField name="*_b" type="boolean" indexed="true" stored="false"/>
+   <dynamicField name="*_d" type="date" indexed="true" stored="false"/>
+   <dynamicField name="*_s" type="string" indexed="true" stored="false"/>
+   <dynamicField name="*_ri" type="sint" indexed="true" stored="false"/>
+   <dynamicField name="*_rf" type="sfloat" indexed="true" stored="false"/>
+   <dynamicField name="*_facet" type="string" indexed="true" stored="false"/>
+   <dynamicField name="*_s_mv" type="string" indexed="true" stored="false" multiValued="true"/>
+   <dynamicField name="*_zh_text" type="text_zh" indexed="true" stored="false" multiValued="true"/>
+   <dynamicField name="*_display" type="text" indexed="false" stored="true" multiValued="true"/>
+ </fields>
+
+ <uniqueKey>id</uniqueKey>
+ <defaultSearchField>text</defaultSearchField>
+
+ <copyField source="*_t" dest="text"/>
+ <copyField source="*_facet" dest="text"/>
+ <solrQueryParser defaultOperator="AND"/>
+
+</schema>
@@ -0,0 +1,24 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+user=
+solr_hostname=localhost
+solr_port=8983
+rsyncd_port=18983
+data_dir=
+webapp_name=solr
+master_host=
+master_data_dir=
+master_status_dir=
@@ -0,0 +1,458 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<!--
+ Licensed to the Apache Software Foundation (ASF) under one or more
+ contributor license agreements.  See the NOTICE file distributed with
+ this work for additional information regarding copyright ownership.
+ The ASF licenses this file to You under the Apache License, Version 2.0
+ (the "License"); you may not use this file except in compliance with
+ the License.  You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+-->
+
+<config>
+  <!-- Set this to 'false' if you want solr to continue working after it has 
+       encountered an severe configuration error.  In a production environment, 
+       you may want solr to keep working even if one handler is mis-configured.
+
+       You may also set this to false using by setting the system property:
+         -Dsolr.abortOnConfigurationError=false
+     -->
+  <abortOnConfigurationError>${solr.abortOnConfigurationError:true}</abortOnConfigurationError>
+
+  <!-- Used to specify an alternate directory to hold all index data
+       other than the default ./data under the Solr home.
+       If replication is in use, this should match the replication configuration. -->
+
+  <dataDir>${solr.data.dir:./solr/data}</dataDir>
+
+  <indexDefaults>
+   <!-- Values here affect all index writers and act as a default unless overridden. -->
+    <useCompoundFile>false</useCompoundFile>
+    <mergeFactor>10</mergeFactor>
+    <maxBufferedDocs>1000</maxBufferedDocs>
+    <maxMergeDocs>2147483647</maxMergeDocs>
+    <maxFieldLength>10000</maxFieldLength>
+    <writeLockTimeout>1000</writeLockTimeout>
+    <commitLockTimeout>10000</commitLockTimeout>
+  </indexDefaults>
+
+  <mainIndex>
+    <!-- options specific to the main on-disk lucene index -->
+    <useCompoundFile>false</useCompoundFile>
+    <mergeFactor>10</mergeFactor>
+    <maxBufferedDocs>1000</maxBufferedDocs>
+    <maxMergeDocs>2147483647</maxMergeDocs>
+    <maxFieldLength>10000</maxFieldLength>
+
+    <!-- If true, unlock any held write or commit locks on startup. 
+         This defeats the locking mechanism that allows multiple
+         processes to safely access a lucene index, and should be
+         used with care. -->
+    <unlockOnStartup>false</unlockOnStartup>
+  </mainIndex>
+
+  <!-- the default high-performance update handler -->
+  <updateHandler class="solr.DirectUpdateHandler2">
+
+    <!-- A prefix of "solr." for class names is an alias that
+         causes solr to search appropriate packages, including
+         org.apache.solr.(search|update|request|core|analysis)
+     -->
+
+    <!-- autocommit pending docs if certain criteria are met 
+    <autoCommit> 
+      <maxDocs>10000</maxDocs>
+      <maxTime>1000</maxTime>
+    </autoCommit>
+    -->
+
+    <!-- The RunExecutableListener executes an external command.
+         exe - the name of the executable to run
+         dir - dir to use as the current working directory. default="."
+         wait - the calling thread waits until the executable returns. default="true"
+         args - the arguments to pass to the program.  default=nothing
+         env - environment variables to set.  default=nothing
+      -->
+    <!-- A postCommit event is fired after every commit or optimize command
+    <listener event="postCommit" class="solr.RunExecutableListener">
+      <str name="exe">snapshooter</str>
+      <str name="dir">solr/bin</str>
+      <bool name="wait">true</bool>
+      <arr name="args"> <str>arg1</str> <str>arg2</str> </arr>
+      <arr name="env"> <str>MYVAR=val1</str> </arr>
+    </listener>
+    -->
+    <!-- A postOptimize event is fired only after every optimize command, useful
+         in conjunction with index distribution to only distribute optimized indicies 
+    <listener event="postOptimize" class="solr.RunExecutableListener">
+      <str name="exe">snapshooter</str>
+      <str name="dir">solr/bin</str>
+      <bool name="wait">true</bool>
+    </listener>
+    -->
+
+  </updateHandler>
+
+
+  <query>
+    <!-- Maximum number of clauses in a boolean query... can affect
+        range or prefix queries that expand to big boolean
+        queries.  An exception is thrown if exceeded.  -->
+    <maxBooleanClauses>1024</maxBooleanClauses>
+
+    
+    <!-- Cache used by SolrIndexSearcher for filters (DocSets),
+         unordered sets of *all* documents that match a query.
+         When a new searcher is opened, its caches may be prepopulated
+         or "autowarmed" using data from caches in the old searcher.
+         autowarmCount is the number of items to prepopulate.  For LRUCache,
+         the autowarmed items will be the most recently accessed items.
+       Parameters:
+         class - the SolrCache implementation (currently only LRUCache)
+         size - the maximum number of entries in the cache
+         initialSize - the initial capacity (number of entries) of
+           the cache.  (seel java.util.HashMap)
+         autowarmCount - the number of entries to prepopulate from
+           and old cache.
+         -->
+    <filterCache
+      class="solr.LRUCache"
+      size="512"
+      initialSize="512"
+      autowarmCount="256"/>
+
+   <!-- queryResultCache caches results of searches - ordered lists of
+         document ids (DocList) based on a query, a sort, and the range
+         of documents requested.  -->
+    <queryResultCache
+      class="solr.LRUCache"
+      size="512"
+      initialSize="512"
+      autowarmCount="256"/>
+
+  <!-- documentCache caches Lucene Document objects (the stored fields for each document).
+       Since Lucene internal document ids are transient, this cache will not be autowarmed.  -->
+    <documentCache
+      class="solr.LRUCache"
+      size="512"
+      initialSize="512"
+      autowarmCount="0"/>
+
+    <!-- If true, stored fields that are not requested will be loaded lazily.
+
+    This can result in a significant speed improvement if the usual case is to
+    not load all stored fields, especially if the skipped fields are large compressed
+    text fields.
+    -->
+    <enableLazyFieldLoading>true</enableLazyFieldLoading>
+
+    <!-- Example of a generic cache.  These caches may be accessed by name
+         through SolrIndexSearcher.getCache(),cacheLookup(), and cacheInsert().
+         The purpose is to enable easy caching of user/application level data.
+         The regenerator argument should be specified as an implementation
+         of solr.search.CacheRegenerator if autowarming is desired.  -->
+    <!--
+    <cache name="myUserCache"
+      class="solr.LRUCache"
+      size="4096"
+      initialSize="1024"
+      autowarmCount="1024"
+      regenerator="org.mycompany.mypackage.MyRegenerator"
+      />
+    -->
+
+   <!-- An optimization that attempts to use a filter to satisfy a search.
+         If the requested sort does not include score, then the filterCache
+         will be checked for a filter matching the query. If found, the filter
+         will be used as the source of document ids, and then the sort will be
+         applied to that.
+    <useFilterForSortedQuery>true</useFilterForSortedQuery>
+   -->
+
+   <!-- An optimization for use with the queryResultCache.  When a search
+         is requested, a superset of the requested number of document ids
+         are collected.  For example, if a search for a particular query
+         requests matching documents 10 through 19, and queryWindowSize is 50,
+         then documents 0 through 50 will be collected and cached.  Any further
+         requests in that range can be satisfied via the cache.  -->
+    <queryResultWindowSize>10</queryResultWindowSize>
+
+    <!-- This entry enables an int hash representation for filters (DocSets)
+         when the number of items in the set is less than maxSize.  For smaller
+         sets, this representation is more memory efficient, more efficient to
+         iterate over, and faster to take intersections.  -->
+    <HashDocSet maxSize="3000" loadFactor="0.75"/>
+
+
+    <!-- boolToFilterOptimizer converts boolean clauses with zero boost
+         into cached filters if the number of docs selected by the clause exceeds
+         the threshold (represented as a fraction of the total index) -->
+    <boolTofilterOptimizer enabled="true" cacheSize="32" threshold=".05"/>
+
+
+    <!-- a newSearcher event is fired whenever a new searcher is being prepared
+         and there is a current searcher handling requests (aka registered). -->
+    <!-- QuerySenderListener takes an array of NamedList and executes a
+         local query request for each NamedList in sequence. -->
+    <!--
+    <listener event="newSearcher" class="solr.QuerySenderListener">
+      <arr name="queries">
+        <lst> <str name="q">solr</str> <str name="start">0</str> <str name="rows">10</str> </lst>
+        <lst> <str name="q">rocks</str> <str name="start">0</str> <str name="rows">10</str> </lst>
+      </arr>
+    </listener>
+    -->
+
+    <!-- a firstSearcher event is fired whenever a new searcher is being
+         prepared but there is no current registered searcher to handle
+         requests or to gain autowarming data from. -->
+    <!--
+    <listener event="firstSearcher" class="solr.QuerySenderListener">
+      <arr name="queries">
+        <lst> <str name="q">fast_warm</str> <str name="start">0</str> <str name="rows">10</str> </lst>
+      </arr>
+    </listener>
+    -->
+
+    <!-- If a search request comes in and there is no current registered searcher,
+         then immediately register the still warming searcher and use it.  If
+         "false" then all requests will block until the first searcher is done
+         warming. -->
+    <useColdSearcher>false</useColdSearcher>
+
+    <!-- Maximum number of searchers that may be warming in the background
+      concurrently.  An error is returned if this limit is exceeded. Recommend
+      1-2 for read-only slaves, higher for masters w/o cache warming. -->
+    <maxWarmingSearchers>4</maxWarmingSearchers>
+
+  </query>
+
+  <!-- 
+    Let the dispatch filter handler /select?qt=XXX
+    handleSelect=true will use consistent error handling for /select and /update
+    handleSelect=false will use solr1.1 style error formatting
+    -->
+  <requestDispatcher handleSelect="true" >
+    <!--Make sure your system has some authentication before enabling remote streaming!  -->
+    <requestParsers enableRemoteStreaming="false" multipartUploadLimitInKB="2048" />
+  </requestDispatcher>
+  
+      
+  <!-- requestHandler plugins... incoming queries will be dispatched to the
+     correct handler based on the qt (query type) param matching the
+     name of registered handlers.
+     The "standard" request handler is the default and will be used if qt
+     is not specified in the request.
+  -->
+  <requestHandler name="standard" class="solr.StandardRequestHandler">
+    <!-- default values for query parameters -->
+     <lst name="defaults">
+       <str name="echoParams">explicit</str>
+	   <str name="json.nl">map</str>
+       <!-- 
+       <int name="rows">10</int>
+       <str name="fl">*</str>
+       <str name="version">2.1</str>
+        -->
+     </lst>
+  </requestHandler>
+
+  <!-- DisMaxRequestHandler allows easy searching across multiple fields
+       for simple user-entered phrases. 
+       see http://wiki.apache.org/solr/DisMaxRequestHandler
+   -->
+  <requestHandler name="dismax" class="solr.DisMaxRequestHandler" >
+    <lst name="defaults">
+     <str name="echoParams">explicit</str>
+     <float name="tie">0.01</float>
+     <str name="qf">
+        text^0.5 features^1.0 name^1.2 sku^1.5 id^10.0 manu^1.1 cat^1.4
+     </str>
+     <str name="pf">
+        text^0.2 features^1.1 name^1.5 manu^1.4 manu_exact^1.9
+     </str>
+     <str name="bf">
+        ord(poplarity)^0.5 recip(rord(price),1,1000,1000)^0.3
+     </str>
+     <str name="fl">
+        id,name,price,score
+     </str>
+     <str name="mm">
+        2&lt;-1 5&lt;-2 6&lt;90%
+     </str>
+     <int name="ps">100</int>
+     <str name="q.alt">*:*</str>
+    </lst>
+  </requestHandler>
+
+  <!-- Note how you can register the same handler multiple times with
+       different names (and different init parameters)
+    -->
+  <requestHandler name="partitioned" class="solr.DisMaxRequestHandler" >
+    <lst name="defaults">
+     <str name="echoParams">explicit</str>
+     <str name="qf">text^0.5 features^1.0 name^1.2 sku^1.5 id^10.0</str>
+     <str name="mm">2&lt;-1 5&lt;-2 6&lt;90%</str>
+     <!-- This is an example of using Date Math to specify a constantly
+          moving date range in a config...
+       -->
+     <str name="bq">incubationdate_dt:[* TO NOW/DAY-1MONTH]^2.2</str>
+    </lst>
+    <!-- In addition to defaults, "appends" params can be specified
+         to identify values which should be appended to the list of
+         multi-val params from the query (or the existing "defaults").
+
+         In this example, the param "fq=instock:true" will be appended to
+         any query time fq params the user may specify, as a mechanism for
+         partitioning the index, independent of any user selected filtering
+         that may also be desired (perhaps as a result of faceted searching).
+
+         NOTE: there is *absolutely* nothing a client can do to prevent these
+         "appends" values from being used, so don't use this mechanism
+         unless you are sure you always want it.
+      -->
+    <lst name="appends">
+      <str name="fq">inStock:true</str>
+    </lst>
+    <!-- "invariants" are a way of letting the Solr maintainer lock down
+         the options available to Solr clients.  Any params values
+         specified here are used regardless of what values may be specified
+         in either the query, the "defaults", or the "appends" params.
+
+         In this example, the facet.field and facet.query params are fixed,
+         limiting the facets clients can use.  Faceting is not turned on by
+         default - but if the client does specify facet=true in the request,
+         these are the only facets they will be able to see counts for;
+         regardless of what other facet.field or facet.query params they
+         may specify.
+
+         NOTE: there is *absolutely* nothing a client can do to prevent these
+         "invariants" values from being used, so don't use this mechanism
+         unless you are sure you always want it.
+      -->
+    <lst name="invariants">
+      <str name="facet.field">cat</str>
+      <str name="facet.field">manu_exact</str>
+      <str name="facet.query">price:[* TO 500]</str>
+      <str name="facet.query">price:[500 TO *]</str>
+    </lst>
+  </requestHandler>
+  
+  <requestHandler name="instock" class="solr.DisMaxRequestHandler" >
+    <!-- for legacy reasons, DisMaxRequestHandler will assume all init
+         params are "defaults" if you don't explicitly specify any defaults.
+      -->
+     <str name="fq">
+        inStock:true
+     </str>
+     <str name="qf">
+        text^0.5 features^1.0 name^1.2 sku^1.5 id^10.0 manu^1.1 cat^1.4
+     </str>
+     <str name="mm">
+        2&lt;-1 5&lt;-2 6&lt;90%
+     </str>
+  </requestHandler>
+
+
+  <!-- SpellCheckerRequestHandler takes in a word (or several words) as the
+       value of the "q" parameter and returns a list of alternative spelling
+       suggestions.  If invoked with a ...&cmd=rebuild, it will rebuild the
+       spellchecker index.
+  -->
+  <requestHandler name="spellchecker" class="solr.SpellCheckerRequestHandler" startup="lazy">
+    <!-- default values for query parameters -->
+     <lst name="defaults">
+       <int name="suggestionCount">1</int>
+       <float name="accuracy">0.5</float>
+     </lst>
+     
+     <!-- Main init params for handler -->
+     
+     <!-- The directory where your SpellChecker Index should live.   -->
+     <!-- May be absolute, or relative to the Solr "dataDir" directory. -->
+     <!-- If this option is not specified, a RAM directory will be used -->
+     <str name="spellcheckerIndexDir">spell</str>
+     
+     <!-- the field in your schema that you want to be able to build -->
+     <!-- your spell index on. This should be a field that uses a very -->
+     <!-- simple FieldType without a lot of Analysis (ie: string) -->
+     <str name="termSourceField">word</str>
+     
+   </requestHandler>
+
+  
+  <!-- Update request handler.  
+  
+       Note: Since solr1.1 requestHandlers requires a valid content type header if posted in 
+       the body. For example, curl now requires: -H 'Content-type:text/xml; charset=utf-8'
+       The response format differs from solr1.1 formatting and returns a standard error code.
+       
+       To enable solr1.1 behavior, remove the /update handler or change its path
+    -->
+  <requestHandler name="/update" class="solr.XmlUpdateRequestHandler" />
+
+  <!-- CSV update handler, loaded on demand -->
+  <requestHandler name="/update/csv" class="solr.CSVRequestHandler" startup="lazy" />
+
+
+  <!-- Admin Handlers.  TODO? There could be a single handler that loads them all... -->
+  <requestHandler name="/admin/luke"       class="org.apache.solr.handler.admin.LukeRequestHandler" />
+  <requestHandler name="/admin/system"     class="org.apache.solr.handler.admin.SystemInfoHandler" />
+  <requestHandler name="/admin/plugins"    class="org.apache.solr.handler.admin.PluginInfoHandler" />
+  <requestHandler name="/admin/threads"    class="org.apache.solr.handler.admin.ThreadDumpHandler" />
+  <requestHandler name="/admin/properties" class="org.apache.solr.handler.admin.PropertiesRequestHandler" />
+  
+  <!-- Echo the request contents back to the client -->
+  <requestHandler name="/debug/dump" class="solr.DumpRequestHandler" >
+    <lst name="defaults">
+     <str name="echoParams">explicit</str> <!-- for all params (including the default etc) use: 'all' -->
+     <str name="echoHandler">true</str>
+    </lst>
+  </requestHandler>
+  
+  <!-- queryResponseWriter plugins... query responses will be written using the
+    writer specified by the 'wt' request parameter matching the name of a registered
+    writer.
+    The "standard" writer is the default and will be used if 'wt' is not specified 
+    in the request. XMLResponseWriter will be used if nothing is specified here.
+    The json, python, and ruby writers are also available by default.
+
+    <queryResponseWriter name="standard" class="org.apache.solr.request.XMLResponseWriter"/>
+    <queryResponseWriter name="json" class="org.apache.solr.request.JSONResponseWriter"/>
+    <queryResponseWriter name="python" class="org.apache.solr.request.PythonResponseWriter"/>
+    <queryResponseWriter name="ruby" class="org.apache.solr.request.RubyResponseWriter"/>
+
+    <queryResponseWriter name="custom" class="com.example.MyResponseWriter"/>
+  -->
+
+  <!-- XSLT response writer transforms the XML output by any xslt file found
+       in Solr's conf/xslt directory.  Changes to xslt files are checked for
+       every xsltCacheLifetimeSeconds.  
+   -->
+  <queryResponseWriter name="xslt" class="org.apache.solr.request.XSLTResponseWriter">
+    <int name="xsltCacheLifetimeSeconds">5</int>
+  </queryResponseWriter> 
+    
+  <!-- config for the admin interface --> 
+  <admin>
+    <defaultQuery>solr</defaultQuery>
+    <gettableFiles>solrconfig.xml schema.xml admin-extra.html</gettableFiles>
+    <!-- pingQuery should be "URLish" ...
+         &amp; separated key=val pairs ... but there shouldn't be any
+         URL escaping of the values -->
+    <pingQuery>
+     qt=standard&amp;q=solrpingquery
+    </pingQuery>
+    <!-- configure a healthcheck file for servers behind a loadbalancer
+    <healthcheck type="file">server-enabled</healthcheck>
+    -->
+  </admin>
+
+</config>
@@ -0,0 +1,57 @@
+# Licensed to the Apache Software Foundation (ASF) under one or more
+# contributor license agreements.  See the NOTICE file distributed with
+# this work for additional information regarding copyright ownership.
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+#-----------------------------------------------------------------------
+# a couple of test stopwords to test that the words are really being
+# configured from this file:
+stopworda
+stopwordb
+
+#Standard english stop words taken from Lucene's StopAnalyzer
+an
+and
+are
+as
+at
+be
+but
+by
+for
+if
+in
+into
+is
+it
+no
+not
+of
+on
+or
+s
+such
+t
+that
+the
+their
+then
+there
+these
+they
+this
+to
+was
+will
+with
+
@@ -0,0 +1,31 @@
+# The ASF licenses this file to You under the Apache License, Version 2.0
+# (the "License"); you may not use this file except in compliance with
+# the License.  You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+#-----------------------------------------------------------------------
+#some test synonym mappings unlikely to appear in real input text
+aaa => aaaa
+bbb => bbbb1 bbbb2
+ccc => cccc1,cccc2
+a\=>a => b\=>b
+a\,a => b\,b
+fooaaa,baraaa,bazaaa
+
+# Some synonym groups specific to this example
+GB,gib,gigabyte,gigabytes
+MB,mib,megabyte,megabytes
+Television, Televisions, TV, TVs
+#notice we use "gib" instead of "GiB" so any WordDelimiterFilter coming
+#after us won't split it into two words.
+
+# Synonym mappings can be used for spelling correction too
+pixima => pixma
+
@@ -0,0 +1,132 @@
+<?xml version='1.0' encoding='UTF-8'?>
+
+<!-- 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ -->
+
+<!-- 
+  Simple transform of Solr query results to HTML
+ -->
+<xsl:stylesheet version='1.0'
+    xmlns:xsl='http://www.w3.org/1999/XSL/Transform'
+>
+
+  <xsl:output media-type="text/html; charset=UTF-8" encoding="UTF-8"/> 
+  
+  <xsl:variable name="title" select="concat('Solr search results (',response/result/@numFound,' documents)')"/>
+  
+  <xsl:template match='/'>
+    <html>
+      <head>
+        <title><xsl:value-of select="$title"/></title>
+        <xsl:call-template name="css"/>
+      </head>
+      <body>
+        <h1><xsl:value-of select="$title"/></h1>
+        <div class="note">
+          This has been formatted by the sample "example.xsl" transform -
+          use your own XSLT to get a nicer page
+        </div>
+        <xsl:apply-templates select="response/result/doc"/>
+      </body>
+    </html>
+  </xsl:template>
+  
+  <xsl:template match="doc">
+    <xsl:variable name="pos" select="position()"/>
+    <div class="doc">
+      <table width="100%">
+        <xsl:apply-templates>
+          <xsl:with-param name="pos"><xsl:value-of select="$pos"/></xsl:with-param>
+        </xsl:apply-templates>
+      </table>
+    </div>
+  </xsl:template>
+
+  <xsl:template match="doc/*[@name='score']" priority="100">
+    <xsl:param name="pos"></xsl:param>
+    <tr>
+      <td class="name">
+        <xsl:value-of select="@name"/>
+      </td>
+      <td class="value">
+        <xsl:value-of select="."/>
+
+        <xsl:if test="boolean(//lst[@name='explain'])">
+          <xsl:element name="a">
+            <!-- can't allow whitespace here -->
+            <xsl:attribute name="href">javascript:toggle("<xsl:value-of select="concat('exp-',$pos)" />");</xsl:attribute>?</xsl:element>
+          <br/>
+          <xsl:element name="div">
+            <xsl:attribute name="class">exp</xsl:attribute>
+            <xsl:attribute name="id">
+              <xsl:value-of select="concat('exp-',$pos)" />
+            </xsl:attribute>
+            <xsl:value-of select="//lst[@name='explain']/str[position()=$pos]"/>
+          </xsl:element>
+        </xsl:if>
+      </td>
+    </tr>
+  </xsl:template>
+
+  <xsl:template match="doc/arr" priority="100">
+    <tr>
+      <td class="name">
+        <xsl:value-of select="@name"/>
+      </td>
+      <td class="value">
+        <ul>
+        <xsl:for-each select="*">
+          <li><xsl:value-of select="."/></li>
+        </xsl:for-each>
+        </ul>
+      </td>
+    </tr>
+  </xsl:template>
+
+
+  <xsl:template match="doc/*">
+    <tr>
+      <td class="name">
+        <xsl:value-of select="@name"/>
+      </td>
+      <td class="value">
+        <xsl:value-of select="."/>
+      </td>
+    </tr>
+  </xsl:template>
+
+  <xsl:template match="*"/>
+  
+  <xsl:template name="css">
+    <script>
+      function toggle(id) {
+        var obj = document.getElementById(id);
+        obj.style.display = (obj.style.display != 'block') ? 'block' : 'none';
+      }
+    </script>
+    <style type="text/css">
+      body { font-family: "Lucida Grande", sans-serif }
+      td.name { font-style: italic; font-size:80%; }
+      td { vertical-align: top; }
+      ul { margin: 0px; margin-left: 1em; padding: 0px; }
+      .note { font-size:80%; }
+      .doc { margin-top: 1em; border-top: solid grey 1px; }
+      .exp { display: none; font-family: monospace; white-space: pre; }
+    </style>
+  </xsl:template>
+
+</xsl:stylesheet>
@@ -0,0 +1,63 @@
+<?xml version='1.0' encoding='UTF-8'?>
+
+<!-- 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ -->
+
+<!-- 
+  Simple transform of Solr query results to Atom
+ -->
+
+<xsl:stylesheet version='1.0'
+    xmlns:xsl='http://www.w3.org/1999/XSL/Transform'>
+
+  <xsl:output method="xml" encoding="utf-8" />
+
+  <xsl:template match='/'>
+    <xsl:variable name="query" select="response/lst[@name='responseHeader']/lst[@name='params']/str[@name='q']"/>
+    <feed xmlns="http://www.w3.org/2005/Atom">
+      <title>Example Solr Atom 1.0 Feed</title>
+      <subtitle>
+       This has been formatted by the sample "example_atom.xsl" transform -
+       use your own XSLT to get a nicer Atom feed.
+      </subtitle>
+      <author>
+        <name>Apache Solr</name>
+        <email>solr-user@lucene.apache.org</email>
+      </author>
+      <link rel="self" type="application/atom+xml" 
+            href="http://localhost:8983/solr/q={$query}&amp;wt=xslt&amp;tr=atom.xsl"/>
+      <updated>
+        <xsl:value-of select="response/result/doc[position()=1]/date[@name='timestamp']"/>
+      </updated>
+      <id>tag:localhost,2007:example</id>
+      <xsl:apply-templates select="response/result/doc"/>
+    </feed>
+  </xsl:template>
+    
+  <!-- search results xslt -->
+  <xsl:template match="doc">
+    <xsl:variable name="id" select="str[@name='id']"/>
+    <entry>
+      <title><xsl:value-of select="str[@name='name']"/></title>
+      <link href="http://localhost:8983/solr/select?q={$id}"/>
+      <id>tag:localhost,2007:<xsl:value-of select="$id"/></id>
+      <summary><xsl:value-of select="arr[@name='features']"/></summary>
+      <updated><xsl:value-of select="date[@name='timestamp']"/></updated>
+    </entry>
+  </xsl:template>
+
+</xsl:stylesheet>
@@ -0,0 +1,62 @@
+<?xml version='1.0' encoding='UTF-8'?>
+
+<!-- 
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ -->
+
+<!-- 
+  Simple transform of Solr query results to RSS
+ -->
+
+<xsl:stylesheet version='1.0'
+    xmlns:xsl='http://www.w3.org/1999/XSL/Transform'>
+
+  <xsl:output method="xml" encoding="utf-8" />
+  <xsl:template match='/'>
+    <rss version="2.0">
+       <channel>
+	 <title>Example Solr RSS 2.0 Feed</title>
+         <link>http://localhost:8983/solr</link>
+         <description>
+          This has been formatted by the sample "example_rss.xsl" transform -
+          use your own XSLT to get a nicer RSS feed.
+         </description>
+         <language>en-us</language>
+         <docs>http://localhost:8983/solr</docs>
+         <xsl:apply-templates select="response/result/doc"/>
+       </channel>
+    </rss>
+  </xsl:template>
+  
+  <!-- search results xslt -->
+  <xsl:template match="doc">
+    <xsl:variable name="id" select="str[@name='id']"/>
+    <xsl:variable name="timestamp" select="date[@name='timestamp']"/>
+    <item>
+      <title><xsl:value-of select="str[@name='name']"/></title>
+      <link>
+        http://localhost:8983/solr/select?q=id:<xsl:value-of select="$id"/>
+      </link>
+      <description>
+        <xsl:value-of select="arr[@name='features']"/>
+      </description>
+      <pubDate><xsl:value-of select="$timestamp"/></pubDate>
+      <guid>
+        http://localhost:8983/solr/select?q=id:<xsl:value-of select="$id"/>
+      </guid>
+    </item>
+  </xsl:template>
+</xsl:stylesheet>
@@ -0,0 +1,2 @@
+test:
+  url: http://localhost:8981/solr
 \ No newline at end of file
@@ -0,0 +1,10 @@
+require 'logger'
+ActiveRecord::Base.logger = Logger.new("debug.log")
+
+ActiveRecord::Base.establish_connection(
+  :adapter  => "mysql",
+  :username => MYSQL_USER,
+  :encoding => "utf8",
+  :database => "actsassolr_tests"
+)
+
@@ -0,0 +1,8 @@
+require 'logger'
+ActiveRecord::Base.logger = Logger.new("debug.log")
+
+ActiveRecord::Base.establish_connection(
+  :adapter  => "sqlite3",
+  :encoding => "utf8",
+  :database => File.join(File.dirname(File.expand_path(__FILE__)), '..', '..', 'test.db')
+)
@@ -0,0 +1,15 @@
+class CreateBooks < ActiveRecord::Migration
+  def self.up
+    create_table :books, :force => true do |t|
+      t.column :category_id, :integer
+      t.column :name, :string
+      t.column :author, :string
+      t.column :type, :string
+      t.column :published_on, :date
+    end
+  end
+
+  def self.down
+    drop_table :books
+  end
+end
@@ -0,0 +1,12 @@
+class CreateMovies < ActiveRecord::Migration
+  def self.up
+    create_table :movies, :force => true do |t|
+      t.column :name, :string
+      t.column :description, :string
+    end
+  end
+
+  def self.down
+    drop_table :movies
+  end
+end
@@ -0,0 +1,11 @@
+class CreateCategories < ActiveRecord::Migration
+  def self.up
+    create_table :categories, :force => true do |t|
+      t.column :name, :string
+    end
+  end
+
+  def self.down
+    drop_table :categories
+  end
+end
@@ -0,0 +1,16 @@
+class CreateElectronics < ActiveRecord::Migration
+  def self.up
+    create_table :electronics, :force => true do |t|
+      t.column :name, :string
+      t.column :manufacturer, :string
+      t.column :features, :string
+      t.column :category, :string
+      t.column :price, :string
+      t.timestamps
+    end
+  end
+
+  def self.down
+    drop_table :electronics
+  end
+end
@@ -0,0 +1,12 @@
+class CreateAuthors < ActiveRecord::Migration
+  def self.up
+    create_table :authors, :force => true do |t|
+      t.column :name, :string
+      t.column :biography, :text
+    end
+  end
+
+  def self.down
+    drop_table :authors
+  end
+end
@@ -0,0 +1,9 @@
+class CreatePostings < ActiveRecord::Migration
+  def self.up
+    execute "CREATE TABLE postings(`guid` varchar(20) NOT NULL PRIMARY KEY, `name` varchar(200), `description` text)"
+  end
+
+  def self.down
+    drop_table :postings
+  end
+end
@@ -0,0 +1,13 @@
+class CreatePosts < ActiveRecord::Migration
+  def self.up
+    create_table :posts, :force => true do |t|
+      t.column :name, :string
+      t.column :reply_counter, :integer
+      t.column :posted_at, :datetime
+    end
+  end
+
+  def self.down
+    drop_table :posts
+  end
+end
@@ -0,0 +1,11 @@
+class CreateGadgets < ActiveRecord::Migration
+  def self.up
+    create_table :gadgets, :force => true do |t|
+      t.column :name, :string
+    end
+  end
+
+  def self.down
+    drop_table :gadgets
+  end
+end
@@ -0,0 +1,9 @@
+tom_clancy:
+  id: 1
+  name: Tom Clancy
+  biography: Tom Clancy (born 1947) writes novels of adventure and espionage in the international military-industrial complex that have earned him enormous popularity in the 1980s as a creator of the "techno-thriller" genre.
+  
+stephen_king:
+  id: 2
+  name: Stephen King
+  biography: Stephen King (born 1947) is a prolific and immensely popular author of horror fiction. In his works, King blends elements of the traditional gothic tale with those of the modern psychological thriller, detective, and science fiction genres.
@@ -0,0 +1,13 @@
+splinter_cell:
+  id: 1
+  category_id: 1
+  name: Splinter Cell
+  author: Tom Clancy
+  published_on: <%= Date.today - 1.year %>
+  
+ruby:
+  id: 2
+  category_id: 2
+  name: Ruby for Dummies
+  author: Peter McPeterson
+  published_on: <%= Date.today - 2.years %>
 \ No newline at end of file
@@ -0,0 +1,7 @@
+thriller:
+  id: 1
+  name: Thriller/Novels
+  
+technical:
+  id: 2
+  name: Technical Books
 \ No newline at end of file
@@ -0,0 +1,41 @@
+DROP DATABASE IF EXISTS `actsassolr_tests`;
+CREATE DATABASE IF NOT EXISTS `actsassolr_tests`;
+USE `actsassolr_tests`
+
+CREATE TABLE `books` (
+  `id` int(11) NOT NULL auto_increment,
+  `category_id` int(11),
+  `name` varchar(200) default NULL,
+  `author` varchar(200) default NULL,
+  PRIMARY KEY  (`id`)
+);
+
+CREATE TABLE `movies` (
+  `id` int(11) NOT NULL auto_increment,
+  `name` varchar(200) default NULL,
+  `description` varchar(255) default NULL,
+  PRIMARY KEY  (`id`)
+);
+
+CREATE TABLE `categories` (
+  `id` int(11) NOT NULL auto_increment,
+  `name` varchar(200) default NULL,
+  PRIMARY KEY  (`id`)
+);
+
+CREATE TABLE `electronics` (
+  `id` int(11) NOT NULL auto_increment,
+  `name` varchar(200) default NULL,
+  `manufacturer` varchar(255) default NULL,
+  `features` varchar(255) default NULL,
+  `category` varchar(255) default NULL, 
+  `price` varchar(20) default NULL,
+  PRIMARY KEY  (`id`)
+);
+
+CREATE TABLE `authors` (
+  `id` int(11) NOT NULL auto_increment,
+  `name` varchar(200) default NULL,
+  `biography` text default NULL,
+  PRIMARY KEY  (`id`)
+);
@@ -0,0 +1,49 @@
+ipod_video:
+  id: 1
+  name: Apple 60 GB Memory iPod with Video Playback Black
+  manufacturer: Apple Computer Inc.
+  features: iTunes, Podcasts, Audiobooks
+  category: Electronics
+  price: 599.00
+  created_at: <%= Date.today - 1.year %>
+  updated_at: <%= Date.today - 1.month %>
+  
+dell_monitor:
+  id: 2
+  name: Dell Widescreen UltraSharp 3007WFP
+  manufacturer: Dell, Inc
+  features: 30" TFT active matrix LCD, 2560 x 1600, .25mm dot pitch, 700:1 contrast
+  category: Electronics
+  price: 750.00
+  created_at: <%= Date.today - 1.year %>
+  updated_at: <%= Date.today - 1.month %>
+  
+samsung_hd:
+  id: 3
+  name: Samsung SpinPoint P120 SP2514N - hard drive - 250 GB of Memory Storage - ATA-133
+  manufacturer: Samsung Electronics Co. Ltd.
+  features: 7200RPM, 8MB cache, IDE Ultra ATA-133
+  category: Hard Drive
+  price: 319.00
+  created_at: <%= Date.today - 2.years %>
+  updated_at: <%= Date.today - 2.months %>
+  
+corsair_ram:
+  id: 4
+  name: CORSAIR XMS 2GB (2 x 1GB) 184-Pin DDR SDRAM Unbuffered DDR 400 (PC 3200) Dual Channel Kit System Memory - Retail
+  manufacturer: Corsair Microsystems Inc.
+  features: CAS latency 2,	2-3-3-6 timing, 2.75v, unbuffered, heat-spreader
+  category: Memory
+  price: 155.00
+  created_at: <%= Date.today - 6.years %>
+  updated_at: <%= Date.today - 3.months %>
+  
+a_data_ram:
+  id: 5
+  name: A-DATA V-Series 1GB 184-Pin DDR SDRAM Unbuffered DDR 400 (PC 3200) System Memory - OEM
+  manufacturer: A-DATA Technology Inc.
+  features: CAS latency 3, 2.7v
+  category: Memory
+  price: 65.79
+  created_at: <%= Date.today - 9.years %>
+  updated_at: <%= Date.today - 4.months %>
@@ -0,0 +1,9 @@
+napoleon_dynamite:
+  id: 1
+  name: Napoleon Dynamite
+  description: Cool movie about a goofy guy
+  
+office_space:
+  id: 2
+  name: Office Space
+  description: Hypnotized dude loves fishing but not working
 \ No newline at end of file
@@ -0,0 +1,10 @@
+first:
+  guid: ABC-123
+  name: Posting ABC
+  description: First posting testing primary key as string
+
+second:
+  guid: DEF-456
+  name: Posting DEF
+  description: Second posting testing primary key as string
+
@@ -0,0 +1,413 @@
+# encoding: utf-8
+require "#{File.dirname(File.expand_path(__FILE__))}/../test_helper"
+
+class ActsAsSolrTest < Test::Unit::TestCase
+  
+  fixtures :books, :movies, :electronics, :postings, :authors
+
+  # Inserting new data into Solr and making sure it's getting indexed
+  def test_insert_new_data
+    assert_equal 2, Book.count_by_solr('ruby OR splinter OR bob')
+    b = Book.create(:name => "Fuze in action", :author => "Bob Bobber", :category_id => 1)
+    assert b.valid?
+    assert_equal 3, Book.count_by_solr('ruby OR splinter OR bob')
+  end
+  
+  # Check the type column stored in the index isn't stemmed by SOLR.  If it is stemmed,
+  # then both Post and Posting will be stored as type:Post, so a query for Posts will
+  # return Postings and vice versa
+  
+  def test_insert_new_data_doesnt_stem_type
+    assert_equal 0, Post.count_by_solr('aardvark')
+    p = Posting.new :name => 'aardvark', :description => "An interesting animal"
+    p.guid = '12AB'
+    p.save!
+    assert_equal 0, Post.count_by_solr('aardvark')
+  end
+
+  def test_type_determined_from_database_if_not_explicitly_set
+    assert Post.configuration[:solr_fields][:posted_at][:type] == :date
+  end
+  
+  def test_search_includes_subclasses
+    Novel.create! :name => 'Wuthering Heights', :author => 'Emily Bronte'
+    Book.create! :name => 'Jane Eyre', :author => 'Charlotte Bronte'
+    assert_equal 1, Novel.find_by_solr('Bronte').total_hits
+    assert_equal 2, Book.find_by_solr('Bronte').total_hits
+  end
+
+  # Testing basic solr search:
+  #  Model.find_by_solr 'term'
+  # Note that you're able to mix free-search with fields and boolean operators
+  def test_find_by_solr_ruby
+    ['ruby', 'dummy', 'name:ruby', 'name:dummy', 'name:ruby AND author:peter', 
+      'author:peter AND ruby', 'peter dummy'].each do |term|
+      records = Book.find_by_solr term
+      assert_equal 1, records.total
+      assert_equal "Peter McPeterson", records.docs.first.author
+      assert_equal "Ruby for Dummies", records.docs.first.name
+      assert_equal ({"id" => 2, 
+                      "category_id" => 2, 
+                      "name" => "Ruby for Dummies", 
+                      "author" => "Peter McPeterson", "published_on" => (Date.today - 2.years), "type" => nil}), records.docs.first.attributes
+    end
+  end
+  
+  # Testing basic solr search:
+  #   Model.find_by_solr 'term'
+  # Note that you're able to mix free-search with fields and boolean operators
+  def test_find_by_solr_splinter
+    ['splinter', 'name:splinter', 'name:splinter AND author:clancy', 
+      'author:clancy AND splinter', 'cell tom'].each do |term|
+      records = Book.find_by_solr term
+      assert_equal 1, records.total
+      assert_equal "Splinter Cell", records.docs.first.name
+      assert_equal "Tom Clancy", records.docs.first.author
+      assert_equal ({"id" => 1, "category_id" => 1, "name" => "Splinter Cell", 
+                     "author" => "Tom Clancy", "published_on" => (Date.today - 1.year), "type" => nil}), records.docs.first.attributes
+    end
+  end
+  
+  # Testing basic solr search:
+  #   Model.find_by_solr 'term'
+  # Note that you're able to mix free-search with fields and boolean operators
+  def test_find_by_solr_ruby_or_splinter
+    ['ruby OR splinter', 'ruby OR author:tom', 'name:cell OR author:peter', 'dummy OR cell'].each do |term|
+      records = Book.find_by_solr term
+      assert_equal 2, records.total
+    end
+  end
+  
+  # Testing search in indexed field methods:
+  # 
+  # class Movie < ActiveRecord::Base
+  #   acts_as_solr :fields => [:name, :description, :current_time]
+  # 
+  #   def current_time
+  #     Time.now.to_s
+  #   end
+  # 
+  # end
+  # 
+  # The method current_time above gets indexed as being part of the
+  # Movie model and it's available for search as well
+  def test_find_with_dynamic_fields
+    date = Time.now.strftime('%b %d %Y')
+    ["dynamite AND #{date}", "description:goofy AND #{date}", "goofy napoleon #{date}", 
+      "goofiness #{date}"].each do |term|
+      records = Movie.find_by_solr term 
+      assert_equal 1, records.total
+      assert_equal ({"id" => 1, "name" => "Napoleon Dynamite", 
+                     "description" => "Cool movie about a goofy guy"}), records.docs.first.attributes
+    end
+  end
+  
+  # Testing basic solr search that returns just the ids instead of the objects:
+  #   Model.find_id_by_solr 'term'
+  # Note that you're able to mix free-search with fields and boolean operators
+  def test_find_id_by_solr_ruby
+    ['ruby', 'dummy', 'name:ruby', 'name:dummy', 'name:ruby AND author:peter', 
+      'author:peter AND ruby'].each do |term|
+      records = Book.find_id_by_solr term
+      assert_equal 1, records.docs.size
+      assert_equal [2], records.docs
+    end
+  end
+  
+  # Testing basic solr search that returns just the ids instead of the objects:
+  #   Model.find_id_by_solr 'term'
+  # Note that you're able to mix free-search with fields and boolean operators
+  def test_find_id_by_solr_splinter
+    ['splinter', 'name:splinter', 'name:splinter AND author:clancy', 
+      'author:clancy AND splinter'].each do |term|
+      records = Book.find_id_by_solr term
+      assert_equal 1, records.docs.size
+      assert_equal [1], records.docs
+    end
+  end
+  
+  # Testing basic solr search that returns just the ids instead of the objects:
+  #   Model.find_id_by_solr 'term'
+  # Note that you're able to mix free-search with fields and boolean operators
+  def test_find_id_by_solr_ruby_or_splinter
+    ['ruby OR splinter', 'ruby OR author:tom', 'name:cell OR author:peter', 
+      'dummy OR cell'].each do |term|
+      records = Book.find_id_by_solr term
+      assert_equal 2, records.docs.size
+      assert_equal [1,2], records.docs
+    end
+  end
+  
+  # Testing basic solr search that returns the total number of records found:
+  #   Model.find_count_by_solr 'term'
+  # Note that you're able to mix free-search with fields and boolean operators
+  def test_count_by_solr
+    ['ruby', 'dummy', 'name:ruby', 'name:dummy', 'name:ruby AND author:peter', 
+      'author:peter AND ruby'].each do |term|
+      assert_equal 1, Book.count_by_solr(term), "there should only be 1 result for search: #{term}"
+    end
+  end
+  
+  # Testing basic solr search that returns the total number of records found:
+  #   Model.find_count_by_solr 'term'
+  # Note that you're able to mix free-search with fields and boolean operators
+  def test_count_by_solr_splinter
+    ['splinter', 'name:splinter', 'name:splinter AND author:clancy', 
+      'author:clancy AND splinter', 'author:clancy cell'].each do |term|
+      assert_equal 1, Book.count_by_solr(term)
+    end
+  end
+  
+  # Testing basic solr search that returns the total number of records found:
+  #   Model.find_count_by_solr 'term'
+  # Note that you're able to mix free-search with fields and boolean operators
+  def test_count_by_solr_ruby_or_splinter
+    ['ruby OR splinter', 'ruby OR author:tom', 'name:cell OR author:peter', 'dummy OR cell'].each do |term|
+      assert_equal 2, Book.count_by_solr(term)
+    end
+  end
+    
+  # Testing basic solr search with additional options:
+  # Model.find_count_by_solr 'term', :limit => 10, :offset => 0
+  def test_find_with_options
+    [1,2].each do |count|
+      records = Book.find_by_solr 'ruby OR splinter', :limit => count
+      assert_equal count, records.docs.size
+    end
+  end
+  
+  # Testing self.rebuild_solr_index
+  # - It makes sure the index is rebuilt after a data has been lost
+  def test_rebuild_solr_index
+    assert_equal 1, Book.count_by_solr('splinter')
+    
+    Book.find(:first).solr_destroy
+    assert_equal 0, Book.count_by_solr('splinter')
+    
+    Book.rebuild_solr_index
+    assert_equal 1, Book.count_by_solr('splinter')
+  end
+  
+  # Testing instance methods:
+  # - solr_save
+  # - solr_destroy
+  def test_solr_save_and_solr_destroy
+    assert_equal 1, Book.count_by_solr('splinter')
+  
+    Book.find(:first).solr_destroy
+    assert_equal 0, Book.count_by_solr('splinter')
+    
+    Book.find(:first).solr_save
+    assert_equal 1, Book.count_by_solr('splinter')
+  end
+  
+  # Testing the order of results
+  def test_find_returns_records_in_order
+    records = Book.find_by_solr 'ruby^5 OR splinter'
+    # we boosted ruby so ruby should come first
+  
+    assert_equal 2, records.total
+    assert_equal 'Ruby for Dummies', records.docs.first.name
+    assert_equal 'Splinter Cell', records.docs.last.name    
+  end
+  
+  # Testing solr search with optional :order argument
+  def _test_with_order_option
+    records = Movie.find_by_solr 'office^5 OR goofiness'
+    assert_equal 'Hypnotized dude loves fishing but not working', records.docs.first.description
+    assert_equal 'Cool movie about a goofy guy', records.docs.last.description
+    
+    records = Movie.find_by_solr 'office^5 OR goofiness', :order => 'description asc'
+    assert_equal 'Cool movie about a goofy guy', records.docs.first.description
+    assert_equal 'Hypnotized dude loves fishing but not working', records.docs.last.description
+  end
+  
+  # Testing search with omitted :field_types should 
+  # return the same result set as if when we use it
+  def test_omit_field_types_in_search
+    records  = Electronic.find_by_solr "price:[200 TO 599.99]"
+    assert_match(/599/, records.docs.first.price)
+    assert_match(/319/, records.docs.last.price)
+    
+    records  = Electronic.find_by_solr "price:[200 TO 599.99]", :order => 'price asc'
+    assert_match(/319/, records.docs.first.price)
+    assert_match(/599/, records.docs.last.price)
+    
+  end
+  
+  # Test to make sure the result returned when no matches
+  # are found has the same structure when there are results
+  def test_returns_no_matches
+    records = Book.find_by_solr 'rubyist'
+    assert_equal [], records.docs
+    assert_equal 0, records.total
+    
+    records = Book.find_id_by_solr 'rubyist'
+    assert_equal [], records.docs
+    assert_equal 0, records.total
+    
+    records = Book.find_by_solr 'rubyist', :facets => {}
+    assert_equal [], records.docs
+    assert_equal 0, records.total
+    assert_equal({"facet_fields"=>[]}, records.facets)
+  end
+  
+  
+  # Testing the :exclude_fields option when set in the
+  # model to make sure it doesn't get indexed
+  def test_exclude_fields_option
+    records = Electronic.find_by_solr 'audiobooks OR latency'
+    assert records.docs.empty?
+    assert_equal 0, records.total
+  
+    assert_nothing_raised{
+      records = Electronic.find_by_solr 'features:audiobooks'
+      assert records.docs.empty?
+      assert_equal 0, records.total
+    }
+  end
+  
+  # Testing the :auto_commit option set to false in the model
+  # should not send the commit command to Solr
+  def test_auto_commit_turned_off
+    assert_equal 0, Author.count_by_solr('raymond chandler')
+    
+    original_count = Author.count
+    Author.create(:name => 'Raymond Chandler', :biography => 'Writes noirish detective stories')
+    
+    assert_equal original_count + 1, Author.count
+    assert_equal 0, Author.count_by_solr('raymond chandler')
+  end
+  
+  # Testing models that use a different key as the primary key
+  def test_search_on_model_with_string_id_field
+    records = Posting.find_by_solr 'first^5 OR second'
+    assert_equal 2, records.total
+    assert_equal 'ABC-123', records.docs.first.guid
+    assert_equal 'DEF-456', records.docs.last.guid
+  end
+  
+  # Making sure the result set is ordered correctly even on
+  # models that use a different key as the primary key
+  def test_records_in_order_on_model_with_string_id_field
+    records = Posting.find_by_solr 'first OR second^5'
+    assert_equal 2, records.total
+    assert_equal 'DEF-456', records.docs.first.guid
+    assert_equal 'ABC-123', records.docs.last.guid
+  end
+  
+  # Making sure the records are added when passing a batch size
+  # to rebuild_solr_index
+  def test_using_rebuild_solr_index_with_batch
+    assert_equal 2, Movie.count_by_solr('office OR napoleon')
+    Movie.find(:all).each(&:solr_destroy)
+    assert_equal 0, Movie.count_by_solr('office OR napoleon')
+    
+    Movie.rebuild_solr_index 100
+    assert_equal 2, Movie.count_by_solr('office OR napoleon')
+  end
+  
+  # Making sure find_by_solr with scores actually return the scores
+  # for each individual record
+  def test_find_by_solr_with_score
+    books = Book.find_by_solr 'ruby^10 OR splinter', :scores => true
+    assert_equal 2, books.total
+    assert_equal 0.41763234, books.max_score
+    
+    books.records.each { |book| assert_not_nil book.solr_score }
+    assert_equal 0.41763234, books.docs.first.solr_score
+    assert_equal 0.14354616, books.docs.last.solr_score
+  end
+  
+  # Making sure nothing breaks when html entities are inside
+  # the content to be indexed; and on the search as well.
+  def test_index_and_search_with_html_entities
+    description = "
+    inverted exclamation mark  	&iexcl;  	&#161;
+    ¤ 	currency 	&curren; 	&#164;
+    ¢ 	cent 	&cent; 	&#162;
+    £ 	pound 	&pound; 	&#163;
+    ¥ 	yen 	&yen; 	&#165;
+    ¦ 	broken vertical bar 	&brvbar; 	&#166;
+    § 	section 	&sect; 	&#167;
+    ¨ 	spacing diaeresis 	&uml; 	&#168;
+    © 	copyright 	&copy; 	&#169;
+    ª 	feminine ordinal indicator 	&ordf; 	&#170;
+    « 	angle quotation mark (left) 	&laquo; 	&#171;
+    ¬ 	negation 	&not; 	&#172;
+     	soft hyphen 	&shy; 	&#173;
+    ® 	registered trademark 	&reg; 	&#174;
+    ™ 	trademark 	&trade; 	&#8482;
+    ¯ 	spacing macron 	&macr; 	&#175;
+    ° 	degree 	&deg; 	&#176;
+    ± 	plus-or-minus  	&plusmn; 	&#177;
+    ² 	superscript 2 	&sup2; 	&#178;
+    ³ 	superscript 3 	&sup3; 	&#179;
+    ´ 	spacing acute 	&acute; 	&#180;
+    µ 	micro 	&micro; 	&#181;
+    ¶ 	paragraph 	&para; 	&#182;
+    · 	middle dot 	&middot; 	&#183;
+    ¸ 	spacing cedilla 	&cedil; 	&#184;
+    ¹ 	superscript 1 	&sup1; 	&#185;
+    º 	masculine ordinal indicator 	&ordm; 	&#186;
+    » 	angle quotation mark (right) 	&raquo; 	&#187;
+    ¼ 	fraction 1/4 	&frac14; 	&#188;
+    ½ 	fraction 1/2 	&frac12; 	&#189;
+    ¾ 	fraction 3/4 	&frac34; 	&#190;
+    ¿ 	inverted question mark 	&iquest; 	&#191;
+    × 	multiplication 	&times; 	&#215;
+    ÷ 	division 	&divide; 	&#247
+        &hearts; &diams; &clubs; &spades;"
+    
+    author = Author.create(:name => "Test in Action&trade; - Copyright &copy; Bob", :biography => description)
+    assert author.valid?
+    author.solr_commit
+
+    author = Author.find_by_solr 'trademark &copy &#190 &iexcl &#163'
+    assert_equal 1, author.total
+  end
+  
+  def test_operator_search_option
+    assert_nothing_raised {
+      books = Movie.find_by_solr "office napoleon", :operator => :or
+      assert_equal 2, books.total
+      
+      books = Movie.find_by_solr "office napoleon", :operator => :and
+      assert_equal 0, books.total
+    }
+    
+    assert_raise RuntimeError do
+      Movie.find_by_solr "office napoleon", :operator => :bad
+    end
+  end  
+  
+  # Making sure find_by_solr with scores actually return the scores
+  # for each individual record and orders them accordingly
+  def test_find_by_solr_order_by_score
+    books = Book.find_by_solr 'ruby^10 OR splinter', {:scores => true, :order => 'score asc' }
+    assert (books.docs.collect(&:solr_score).compact.size == books.docs.size), "Each book should have a score"
+    assert_equal 0.41763234, books.docs.last.solr_score
+    
+    books = Book.find_by_solr 'ruby^10 OR splinter', {:scores => true, :order => 'score desc' }
+    assert_equal 0.41763234, books.docs.first.solr_score
+    assert_equal 0.14354616, books.docs.last.solr_score
+  end
+  
+  # Search based on fields with the :date format
+  def test_indexed_date_field_format
+    movies = Movie.find_by_solr 'time_on_xml:[NOW-1DAY TO NOW]'
+    assert_equal 2, movies.total
+  end
+  
+  def test_query_time_is_returned
+    results = Book.find_by_solr('ruby')
+    assert_not_nil(results.query_time)
+    assert_equal(results.query_time.class,Fixnum)
+  end
+  
+  def test_should_not_index_the_record_when_offline_proc_returns_true
+    Gadget.search_disabled = true
+    gadget = Gadget.create(:name => "flipvideo mino")
+    assert_equal 0, Gadget.find_id_by_solr('flipvideo').total
+  end
+end
@@ -0,0 +1,37 @@
+require File.join(File.dirname(__FILE__), '../test_helper')
+
+class AssociationIndexingTest < Test::Unit::TestCase
+  
+  fixtures :categories, :books 
+  
+  # Testing the association indexing with has_many:
+  # 
+  # class Category < ActiveRecord::Base
+  #   has_many :books
+  #   acts_as_solr :include => [:books]
+  # end
+  # 
+  # Note that some of the search terms below are from the 'books'
+  # table, but get indexed as being a part of Category
+  def test_search_on_fields_in_has_many_association
+    ['thriller', 'novel', 'splinter', 'clancy', 'tom clancy thriller'].each do |term|
+      assert_equal 1, Category.count_by_solr(term), "expected one result: #{term}"
+    end
+  end
+  
+  # Testing the association indexing with belongs_to:
+  # 
+  # class Book < ActiveRecord::Base
+  #   belongs_to :category
+  #   acts_as_solr :include => [:category]
+  # end
+  # 
+  # Note that some of the search terms below are from the 'categories'
+  # table, but get indexed as being a part of Book
+  def test_search_on_fields_in_belongs_to_association
+    ['splinter', 'clancy', 'tom clancy thriller', 'splinter novel'].each do |term|
+      assert_equal 1, Book.count_by_solr(term), "expected one result: #{term}"
+    end
+  end
+
+end
@@ -0,0 +1,163 @@
+require File.join(File.dirname(__FILE__), '../test_helper')
+
+class FacetedSearchTest < Test::Unit::TestCase
+  
+  fixtures :electronics
+  
+  # The tests below are for faceted search, but make sure you setup
+  # the fields on your model you'd like to index as a facet field:
+  # 
+  # class Electronic < ActiveRecord::Base
+  #   acts_as_solr :facets => [:category, :manufacturer]  
+  # end
+  # 
+  # A basic faceted search using just one facet field
+  def test_faceted_search_basic
+    records = Electronic.find_by_solr "memory", :facets => {:fields =>[:category]}
+    assert_equal 4, records.docs.size
+    assert_match /Apple 60 GB Memory iPod/, records.docs.first.name
+    assert_equal({"category_facet" => {"Electronics" => 1, 
+                                       "Memory" => 2, 
+                                       "Hard Drive" => 1}}, 
+                 records.facets['facet_fields'])
+  end
+  
+  # Making sure the empty result returned what we expected
+  def test_faceted_search_no_matches
+    records = Electronic.find_by_solr "not found", :facets => { :fields => [:category]}
+    assert_equal [], records.docs
+    assert_equal [], records.facets['facet_fields']
+  end
+  
+  # A basic faceted search using multiple facet fields
+  def test_faceted_search_multiple_fields
+    records = Electronic.find_by_solr "memory", :facets => {:fields =>[:category, :manufacturer]}
+    assert_equal 4, records.docs.size
+    assert_equal({"category_facet" => {"Electronics" => 1, 
+                                       "Memory" => 2, 
+                                       "Hard Drive" => 1},
+                  "manufacturer_facet" => {"Dell, Inc" => 0,
+                                           "Samsung Electronics Co. Ltd." => 1, 
+                                           "Corsair Microsystems Inc." => 1, 
+                                           "A-DATA Technology Inc." => 1,
+                                           "Apple Computer Inc." => 1}}, records.facets['facet_fields'])
+  end
+  
+  # A basic faceted search using facet queries to get counts. 
+  # Here are the facets search query meaning:
+  # "price:[* TO 200]" - Price up to 200
+  # "price:[200 TO 500]" - Price from 200 to 500
+  # "price:[500 TO *]" - Price higher than 500
+  def test_facet_search_with_query
+    records = Electronic.find_by_solr "memory", :facets => {:query => ["price:[* TO 200.00]",
+                                                                          "price:[200.00 TO 500.00]",
+                                                                          "price:[500.00 TO *]"]}
+    assert_equal 4, records.docs.size
+    assert_equal({"facet_queries" => {"price_rf:[* TO 200.00]"=>2,
+                                      "price_rf:[200.00 TO 500.00]"=>1,
+                                      "price_rf:[500.00 TO *]"=>1}, 
+                  "facet_fields" => {}, "facet_dates" => {}}, records.facets)
+  end
+  
+  # Faceted search specifying the query and fields
+  def test_facet_search_with_query_and_field
+    records = Electronic.find_by_solr "memory", :facets => {:query => ["price:[* TO 200.00]",
+                                                                          "price:[200.00 TO 500.00]",
+                                                                          "price:[500.00 TO *]"],
+                                                               :fields => [:category, :manufacturer]}
+    
+    q = records.facets["facet_queries"]
+    assert_equal 2, q["price_rf:[* TO 200.00]"]
+    assert_equal 1, q["price_rf:[500.00 TO *]"]
+    assert_equal 1, q["price_rf:[200.00 TO 500.00]"]
+  
+    f = records.facets["facet_fields"]
+    assert_equal 1, f["category_facet"]["Electronics"]
+    assert_equal 2, f["category_facet"]["Memory"]
+    assert_equal 1, f["category_facet"]["Hard Drive"]
+    assert_equal 1, f["manufacturer_facet"]["Samsung Electronics Co. Ltd."]
+    assert_equal 1, f["manufacturer_facet"]["Corsair Microsystems Inc."]
+    assert_equal 1, f["manufacturer_facet"]["A-DATA Technology Inc."]
+    assert_equal 1, f["manufacturer_facet"]["Apple Computer Inc."]
+  end
+  
+  # Faceted searches with :sort and :zeros options turned on/off
+  def test_faceted_search_using_zero_and_sort
+    records = Electronic.find_by_solr "memory", :facets => {:fields =>[:category]}
+    assert_equal({"category_facet"=>{"Electronics"=>1, "Memory"=>2, "Hard Drive"=>1}}, records.facets['facet_fields'])
+    
+    records = Electronic.find_by_solr "memory", :facets => {:sort => true, :fields =>[:category]}
+    assert_equal({"category_facet"=>{"Memory"=>2, "Electronics"=>1, "Hard Drive"=>1}}, records.facets['facet_fields'])
+    
+    records = Electronic.find_by_solr "memory", :facets => {:fields =>[:manufacturer]}
+    assert_equal({"manufacturer_facet" => {"Dell, Inc" => 0,
+                                          "Samsung Electronics Co. Ltd." => 1, 
+                                          "Corsair Microsystems Inc." => 1, 
+                                          "A-DATA Technology Inc." => 1,
+                                          "Apple Computer Inc." => 1}}, records.facets['facet_fields'])
+  
+    records = Electronic.find_by_solr "memory", :facets => {:zeros => false, :fields =>[:manufacturer]}
+    assert_equal({"manufacturer_facet" => {"Samsung Electronics Co. Ltd." => 1, 
+                                          "Corsair Microsystems Inc." => 1, 
+                                          "A-DATA Technology Inc." => 1,
+                                          "Apple Computer Inc." => 1}}, records.facets['facet_fields'])
+  end
+  
+  # Faceted search with 'drill-down' option being passed.
+  # The :browse option receives the argument in the format:
+  # "facet_field:term". You can drill-down to as many
+  # facet fields as you like
+  def test_faceted_search_with_drill_down
+    records = Electronic.find_by_solr "memory", :facets => {:fields =>[:category]}
+    assert_equal 4, records.docs.size
+    assert_equal({"category_facet"=>{"Electronics"=>1, "Memory"=>2, "Hard Drive"=>1}}, records.facets['facet_fields'])
+    
+    records = Electronic.find_by_solr "memory", :facets => {:fields =>[:category],
+                                                               :browse => "category:Memory",
+                                                               :zeros => false}
+    assert_equal 2, records.docs.size
+    assert_equal({"category_facet"=>{"Memory"=>2}}, records.facets['facet_fields'])
+  end
+  
+  def test_faceted_search_with_dates
+    records = Electronic.find_by_solr "memory", :facets => {:dates => {:fields => [:created_at, :updated_at],
+      :start => (Date.today - 7.years).strftime("%Y-%m-%dT%H:%M:%SZ"), :end => Date.today.strftime("%Y-%m-%dT%H:%M:%SZ"), :gap => '+1YEAR', :other => :all}}
+
+    assert_equal 4, records.docs.size
+    
+    assert_equal 0, records.facets["facet_dates"]["created_at_d"]["after"]
+    assert_equal 1, records.facets["facet_dates"]["created_at_d"]["before"]
+    assert_equal 3, records.facets["facet_dates"]["created_at_d"]["between"]
+    
+    assert_equal 0, records.facets["facet_dates"]["updated_at_d"]["after"]
+    assert_equal 0, records.facets["facet_dates"]["updated_at_d"]["before"]
+    assert_equal 4, records.facets["facet_dates"]["updated_at_d"]["between"]
+  end
+  
+  def test_faceted_search_with_dates_filter
+    records = Electronic.find_by_solr "memory", :facets => {:dates => {:filter => ["updated_at:[#{(Date.today - 3.months).strftime("%Y-%m-%dT%H:%M:%SZ")} TO NOW-1MONTH/DAY]"]}}
+    
+    assert_equal 2, records.docs.size
+    
+    records.docs.each { |r|
+      assert r.updated_at >= (Date.today - 3.month)
+      assert r.updated_at <= (Date.today - 1.month)
+    }
+  end
+  
+  def test_faceted_search_with_dates_filter_and_facets
+    # this is a very contrived example but gives us data to validate
+    records = Electronic.find_by_solr "memory", :facets => {:dates => {:filter => ["updated_at:[#{(Date.today - 3.months).strftime("%Y-%m-%dT%H:%M:%SZ")} TO NOW-1MONTH/DAY]"],
+      :fields => [:created_at, :updated_at], :start => 'NOW-2MONTHS/DAY', :end => 'NOW-1MONTH/DAY', :gap => '+1MONTH', :other => :all}}
+    
+    assert_equal 2, records.docs.size
+    
+    assert_equal 0, records.facets["facet_dates"]["created_at_d"]["after"]
+    assert_equal 2, records.facets["facet_dates"]["created_at_d"]["before"]
+    assert_equal 0, records.facets["facet_dates"]["created_at_d"]["between"]
+    
+    assert_equal 0, records.facets["facet_dates"]["updated_at_d"]["after"]
+    assert_equal 1, records.facets["facet_dates"]["updated_at_d"]["before"]
+    assert_equal 1, records.facets["facet_dates"]["updated_at_d"]["between"]
+  end
+end
...	...	@@ -0,0 +1,8 @@
	1	+*.log
	2	+*.log
	3	+*_pid
	4	+coverage/*
	5	+coverage.data
	6	+solr/solr/data/*
	7	+.svn
	8	+test/db/*.db
...	...
...	...	@@ -0,0 +1,233 @@
	1	+== CHANGE_LOG
	2	+=== Development
	3	+<b>NEW</b>:: A unit test suite based on Shoulda, not requiring a running Solr or a Rails environment. (Mathias Meyer)
	4	+<b>NEW</b>:: Added the :offline option to the acts_as_solr method. (Mathias Meyer)
	5	+<b>NEW</b>:: Added :lazy flag to find_by_solr, and with that support to load records lazily. (Mathias Meyer)
	6	+<b>FIX</b>:: Added test: to solr.yml so you don't need to do this by hand. (Ken Harris)
	7	+<b>FIX</b>:: Updated bundled Solr to 1.3. (Mathias Meyer)
	8	+<b>FIX</b>:: Updated bundled solr-ruby to 0.0.6 which comes bundled with Solr 1.3. (Mathias Meyer)
	9	+<b>FIX</b>:: Improved logging of the reindex rake task. (David Stevenson)
	10	+<b>FIX</b>:: Added requirement for libxml-ruby > 0.7, if libxml-ruby is installed. (David Stevenson)
	11	+<b>FIX</b>:: Ruby 1.9 compatibility fixes. (David Palm)
	12	+<b>FIX</b>:: Fixed compatibility with Desert by renaming environment.rb to solr_environment.rb. (David Stevenson)
	13	+<b>FIX</b>:: Moved the require of solr_environment only into tasks that need it. (David Stevenson)
	14	+<b>NEW</b>:: Added support to alias fields and includes using the option :as for acts_as_solr. See the RDoc for details. (Nick Hengeveld)
	15	+<b>NEW</b>:: Added support to attach the score to multi search results. (Mathias Meyer)
	16	+<b>NEW</b>:: Added support for facets on date fields. (Curtis Hatter)
	17	+
	18	+=== 06-18-2007: Version 0.9
	19	+<b>NEW</b>:: Added the option :scores when doing a search. If set to true this will return the score as a 'solr_score' attribute or each one of the instances found
	20	+ books = Book.find_by_solr 'ruby OR splinter', :scores => true
	21	+ books.records.first.solr_score
	22	+ => 1.21321397
	23	+ books.records.last.solr_score
	24	+ => 0.12321548
	25	+
	26	+<b>NEW</b>:: Major change on the way the results returned are accessed.
	27	+ books = Book.find_by_solr 'ruby'
	28	+ # the above will return a SearchResults class with 4 methods:
	29	+ # docs\|results\|records: will return an array of records found
	30	+ #
	31	+ # books.records.is_a?(Array)
	32	+ # => true
	33	+ #
	34	+ # total\|num_found\|total_hits: will return the total number of records found
	35	+ #
	36	+ # books.total
	37	+ # => 2
	38	+ #
	39	+ # facets: will return the facets when doing a faceted search
	40	+ #
	41	+ # max_score\|highest_score: returns the highest score found
	42	+ #
	43	+ # books.max_score
	44	+ # => 1.3213213
	45	+
	46	+<b>NEW</b>:: Integrating acts_as_solr to use solr-ruby as the 'backend'. Integration based on the patch submitted by Erik Hatcher
	47	+<b>NEW</b>:: Re-factoring rebuild_solr_index to allow adds to be done in batch; and if a finder block is given, it will be called to retrieve the items to index. (thanks Daniel E.)
	48	+<b>NEW</b>:: Adding the option to specify the port Solr should start when using rake solr:start
	49	+ rake solr:start RAILS_ENV=your_env PORT=XX
	50	+
	51	+<b>NEW</b>:: Adding deprecation warning for the :background configuration option. It will no longer be updated.
	52	+<b>NEW</b>:: Adding support for models that use a primary key other than integer
	53	+ class Posting < ActiveRecord::Base
	54	+ set_primary_key 'guid' #string
	55	+ #make sure you set the :primary_key_field => 'pk_s' if you wish to use a string field as the primary key
	56	+ acts_as_solr({},{:primary_key_field => 'pk_s'})
	57	+ end
	58	+
	59	+<b>FIX</b>:: Disabling of storing most fields. Storage isn't useful for acts_as_solr in any field other than the pk and id fields. It just takes up space and time. (thanks Daniel E.)
	60	+<b>FIX</b>:: Re-factoring code submitted by Daniel E.
	61	+<b>NEW</b>:: Adding an :auto_commit option that will only send the commit command to Solr if it is set to true
	62	+ class Author < ActiveRecord::Base
	63	+ acts_as_solr :auto_commit => false
	64	+ end
	65	+
	66	+<b>FIX</b>:: Fixing bug on rake's test task
	67	+<b>FIX</b>:: Making acts_as_solr's Post class compatible with Solr 1.2 (thanks Si)
	68	+<b>NEW</b>:: Adding Solr 1.2
	69	+<b>FIX</b>:: Removing Solr 1.1
	70	+<b>NEW</b>:: Adding a conditional :if option to the acts_as_solr call. It behaves the same way ActiveRecord's :if argument option does.
	71	+ class Electronic < ActiveRecord::Base
	72	+ acts_as_solr :if => proc{\|record\| record.is_active?}
	73	+ end
	74	+
	75	+<b>NEW</b>:: Adding fixtures to Solr index when using rake db:fixtures:load
	76	+<b>FIX</b>:: Fixing boost warning messages
	77	+<b>FIX</b>:: Fixing bug when adding a facet to a field that contains boost
	78	+<b>NEW</b>:: Deprecating find_with_facet and combining functionality with find_by_solr
	79	+<b>NEW</b>:: Adding the option to :exclude_fields when indexing a model
	80	+ class User < ActiveRecord::Base
	81	+ acts_as_solr :exclude_fields => [:password, :login, :credit_card_number]
	82	+ end
	83	+
	84	+<b>FIX</b>:: Fixing branch bug on older ruby version
	85	+<b>NEW</b>:: Adding boost support for fields and documents being indexed:
	86	+ class Electronic < ActiveRecord::Base
	87	+ # You can add boosting on a per-field basis or on the entire document
	88	+ acts_as_solr :fields => [{:price => {:boost => 5.0}}], :boost => 5.0
	89	+ end
	90	+
	91	+<b>FIX</b>:: Fixed the acts_as_solr limitation to only accept test\|development\|production environments.
	92	+
	93	+=== 05-16-2007: Version 0.8.5
	94	+<b>FIX</b>:: There's no need to specify the :field_types anymore when doing a search in a model that specifies a field type for a field.
	95	+<b>FIX</b>:: Better handling of nil values from indexed fields. Solr complained when indexing fields with field type and the field values being passed as nils.
	96	+<b>NEW</b>:: Adding Solr sort (order by) option to the search query (thanks Kevin Hunt)
	97	+<b>FIX</b>:: Applying patch suggested for increasing the Solr commit speed (thanks Mourad Hammiche)
	98	+<b>FIX</b>:: Updated documentation
	99	+
	100	+=== 05-10-2007: Version 0.8
	101	+<b>NEW</b>: New video tutorial
	102	+<b>NEW</b>: Faceted search has been implemented and its possible to 'drill-down' on the facets
	103	+<b>NEW</b>: New rake tasks you can use to start/stop the solr server in test, development and production environments: (thanks Matt Clark)
	104	+ rake solr:start\|stop RAILS_ENV=test\|development\|production (defaults to development if none given)
	105	+
	106	+<b>NEW</b>: Changes to the plugin's test framework and it now supports Sqlite as well (thanks Matt Clark)
	107	+<b>FIX</b>: Patch applied (thanks Micah) that allows one to have multiple solr instances in the same servlet
	108	+<b>FIX</b>: Patch applied (thanks Micah) that allows indexing of STIs
	109	+<b>FIX</b>: Patch applied (thanks Gordon) that allows the plugin to use a table's primary key different than 'id'
	110	+<b>FIX</b>: Returning empty array instead of empty strings when no records are found
	111	+<b>FIX</b>: Problem with unit tests failing due to order of the tests and speed of the commits
	112	+
	113	+=== 02-16-2007: Version 0.7
	114	+<b>NEW</b>: You can now specify the field types when indexing and searching if
	115	+you'd like to preserve its original type:
	116	+
	117	+<b>Indexing</b>
	118	+
	119	+Each field passed can also be a hash with the value being a field type
	120	+
	121	+ class Electronic < ActiveRecord::Base
	122	+ acts_as_solr :fields => [{:price => :range_float}, {:current_time => :date}]
	123	+ def current_time
	124	+ Time.now
	125	+ end
	126	+ end
	127	+
	128	+<b>Searching</b>
	129	+ Electronic.find_by_solr "ipod AND price:[* TO 59.99]",
	130	+ :field_types => [{:price => :range_float}]
	131	+
	132	+The field types accepted are:
	133	+<em>:float</em>:: Index the field value as a float (ie.: 12.87)
	134	+<em>:integer</em>:: Index the field value as an integer (ie.: 31)
	135	+<em>:boolean</em>:: Index the field value as a boolean (ie.: true/false)
	136	+<em>:date</em>:: Index the field value as a date (ie.: Wed Nov 15 23:13:03 PST 2006)
	137	+<em>:string</em>:: Index the field value as a text string, not applying the same indexing filters as a regular text field
	138	+<em>:range_integer</em>:: Index the field value for integer range queries (ie.:[5 TO 20])
	139	+<em>:range_float</em>:: Index the field value for float range queries (ie.:[14.56 TO 19.99])
	140	+
	141	+<b>Setting the field type preserves its original type when indexed</b>
	142	+
	143	+<b>FIX</b>: Fixing sorting bug. Thanks for the catch Laurel
	144	+
	145	+<b>FIX</b>: Fixing small bug when installing the plugin
	146	+
	147	+<b>NEW</b>: Adding the :additional_fields option to the acts_as_solr method
	148	+
	149	+=== 02-05-2007: Version 0.6.5
	150	+<b>NEW</b>:: Added multi-model search, which can be used to execute a search across multiple models:
	151	+ Book.multi_solr_search "Napoleon OR Tom", :models => [Movie]
	152	+
	153	+====options:
	154	+Accepts the same options as find_by_solr plus:
	155	+models:: The additional models you'd like to include in the search
	156	+results_format:: Specify the format of the results found
	157	+ :objects :: Will return an array with the results being objects (default). Example:
	158	+ Book.multi_solr_search "Napoleon OR Tom", :models => [Movie], :results_format => :objects
	159	+ :ids :: Will return an array with the ids of each entry found. Example:
	160	+ Book.multi_solr_search "Napoleon OR Tom", :models => [Movie], :results_format => :ids
	161	+ => [{"id" => "Movie:1"},{"id" => Book:1}]
	162	+ Where the value of each array is as Model:instance_id
	163	+
	164	+=== 02-03-2007: Version 0.6
	165	+<b>NEW</b>:: Added basic faceted search functionality for indexing and searching:
	166	+
	167	+==== Indexing:
	168	+
	169	+ class Electronic < ActiveRecord::Base
	170	+ acts_as_solr :facets => [:category, :manufacturer]
	171	+ end
	172	+
	173	+==== Searching:
	174	+
	175	+ Electronic.find_with_facet "memory", :facets => {:fields =>[:category]}
	176	+
	177	+=== 01-15-2007: Version 0.5
	178	+<b>NEW</b>:: Added model association indexing, which means you can include any :has_one, :has_many,
	179	+:belongs_to and :has_and_belongs_to_many association to be indexed:
	180	+
	181	+ class Category < ActiveRecord::Base
	182	+ has_many :books
	183	+ acts_as_solr :include => [:books]
	184	+ end
	185	+
	186	+ class Book < ActiveRecord::Base
	187	+ belongs_to :category
	188	+ acts_as_solr :include => [:category]
	189	+ end
	190	+
	191	+=== 01-11-2007:
	192	+<b>NEW</b>:: Added the acts_as_solr's plugin tests
	193	+
	194	+=== 11-07-2006: Version 0.4
	195	+<b>NEW</b>:: Added :background option, which takes and integer value (in minutes) to wait before committing the changes to Solr. This depends on rail_cron being installed. By setting up the background job we prevent the users from having to wait for Solr records to be created, and we keep from updating the index over and over for quickly successive changes. (Rob Kaufman)
	196	+
	197	+=== 11-02-2006: Version 0.3
	198	+<b>NEW</b>:: Added a method (Model.count_by_solr) that returns the total number of documents found based on query passed
	199	+<b>NEW</b>:: Added configuration for production and development environments
	200	+
	201	+=== 10-21-2006: Version 0.2
	202	+<b>PLUGIN</b>
	203	+<b>FIX</b>:: Fixed bug when mixing search-by-field and 'free' search: Model.find_by_solr 'solr AND name:Thiago'
	204	+<b>FIX</b>:: Fixed bug with multi-terms search: Book.find_by_solr 'anteater john'
	205	+<b>FIX</b>:: Fixed bug when including more than one search field: Model.find_by_solr 'name:Thiago AND engine:Solr'
	206	+<b>FIX</b>:: Fixed bug when rebuilding the index, it wasn't saving the data
	207	+<b>NEW</b>:: Added the ability to index custom methods from a model as search fields
	208	+<b>NEW</b>:: Added a search method (Model.find_id_by_solr) that will return only the id of the results
	209	+
	210	+<b>SCHEMA.XML</b>
	211	+<b>NEW</b>:: Added a new field: <field name="default" type="text" indexed="true" stored="true" />
	212	+<b>NEW</b>:: Added a default search field: <defaultSearchField>default</defaultSearchField>
	213	+<b>FIX</b>:: Changed the defaultOperator to AND instead of OR
	214	+
	215	+=== 09-29-2006: Version 0.1
	216	+<b>PLUGIN</b>
	217	+<b>NEW</b>:: Included the option of having a Solr config file inside the rails env.
	218	+<b>NEW</b>:: Added the ability of indexing only certain fields, if you chose to.
	219	+<b>NEW</b>:: Added configuration options
	220	+<b>NEW</b>:: Changed the way the search was done:
	221	+ Old: You were forced the specify the field you wanted to look for
	222	+ ('field:value') and you had to specify a default search field as
	223	+ well, for when you didn't include the 'field' in the search term
	224	+ New: The new search features include:
	225	+ - You don't have to specify a default search field;
	226	+ - You are not forced to include the field name in the search term,
	227	+ unless you choose to search for a specific field ('name:Thiago');
	228	+ - You can pass the starting row and the number of rows per page,
	229	+ which is usefull for pagination
	230	+<b>NEW</b>:: Included a method to rebuild the index files
	231	+
	232	+<b>SCHEMA.XML</b>
	233	+<b>NEW</b>:: Created an optimized version of the config file to better work with this plugin
0	234	\ No newline at end of file
...	...
...	...	@@ -0,0 +1,19 @@
	1	+Copyright (c) 2006 Erik Hatcher, Thiago Jackiw
	2	+
	3	+Permission is hereby granted, free of charge, to any person obtaining a copy
	4	+of this software and associated documentation files (the "Software"), to deal
	5	+in the Software without restriction, including without limitation the rights
	6	+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	7	+copies of the Software, and to permit persons to whom the Software is
	8	+furnished to do so, subject to the following conditions:
	9	+
	10	+The above copyright notice and this permission notice shall be included in all
	11	+copies or substantial portions of the Software.
	12	+
	13	+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	14	+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	15	+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	16	+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	17	+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	18	+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	19	+SOFTWARE.
0	20	\ No newline at end of file
...	...
...	...	@@ -0,0 +1,94 @@
	1	+`acts_as_solr` Rails plugin
	2	+======
	3	+This plugin adds full text search capabilities and many other nifty features from Apache's [Solr](http://lucene.apache.org/solr/) to any Rails model.
	4	+It was based on the first draft by Erik Hatcher.
	5	+
	6	+Current Release
	7	+======
	8	+The current stable release is v0.9 and was released on 06-18-2007.
	9	+
	10	+Changes
	11	+======
	12	+Please refer to the CHANGE_LOG
	13	+
	14	+Installation
	15	+======
	16	+
	17	+For Rails >= 2.1:
	18	+
	19	+ script/plugin install git://github.com/mattmatt/acts_as_solr.git
	20	+
	21	+For Rails < 2.1:
	22	+
	23	+ cd vendor/plugins
	24	+ git clone git://github.com/mattmatt/acts_as_solr.git
	25	+ rm -rf acts_as_solr/.git
	26	+
	27	+Make sure you copy `vendor/plugins/acts_as_solr/config/solr.yml` to your Rails
	28	+application's config directory, when you install via `git clone`.
	29	+
	30	+Requirements
	31	+------
	32	+* Java Runtime Environment(JRE) 1.5 aka 5.0 [http://www.java.com/en/download/index.jsp](http://www.java.com/en/download/index.jsp)
	33	+* If you have libxml-ruby installed, make sure it's at least version 0.7
	34	+
	35	+Configuration
	36	+======
	37	+Basically everything is configured to work out of the box. You can use `rake solr:start` and `rake solr:stop`
	38	+to start and stop the Solr web server (an embedded Jetty). If the default JVM options aren't suitable for
	39	+your environment, you can configure them in solr.yml with the option `jvm_options`. There is a default
	40	+set for the production environment to have some more memory available for the JVM than the defaults, but
	41	+feel free to change them to your liking.
	42	+
	43	+Basic Usage
	44	+======
	45	+<pre><code>
	46	+# Just include the line below to any of your ActiveRecord models:
	47	+ acts_as_solr
	48	+
	49	+# Or if you want, you can specify only the fields that should be indexed:
	50	+ acts_as_solr :fields => [:name, :author]
	51	+
	52	+# Then to find instances of your model, just do:
	53	+ Model.find_by_solr(query) #query is a string representing your query
	54	+
	55	+# Please see ActsAsSolr::ActsMethods for a complete info
	56	+
	57	+</code></pre>
	58	+
	59	+
	60	+`acts_as_solr` in your tests
	61	+======
	62	+To test code that uses `acts_as_solr` you must start a Solr server for the test environment. You can do that with `rake solr:start RAILS_ENV=test`
	63	+
	64	+However, if you would like to mock out Solr calls so that a Solr server is not needed (and your tests will run much faster), just add this to your `test_helper.rb` or similar:
	65	+
	66	+<pre><code>
	67	+class ActsAsSolr::Post
	68	+ def self.execute(request)
	69	+ true
	70	+ end
	71	+end
	72	+</pre></code>
	73	+
	74	+([via](http://www.subelsky.com/2007/10/actsassolr-capistranhttpwwwbloggercomim.html#c1646308013209805416))
	75	+
	76	+Authors
	77	+======
	78	+Erik Hatcher: First draft<br>
	79	+Thiago Jackiw: Previous developer<br>
	80	+Luke Francl: Current developer<br>
	81	+Mathias Meyer: Current developer<br>
	82	+
	83	+Support
	84	+=======
	85	+
	86	+Check the [project website](http://mattmatt.github.com/acts_as_solr) or stop by the [Google Group](http://groups.google.com/group/acts_as_solr). Send bug reports through [GitHub Issues](http://github.com/mattmatt/acts_as_solr/issues).
	87	+
	88	+Release Information
	89	+======
	90	+Released under the MIT license.
	91	+
	92	+More info
	93	+======
	94	+The old [acts_as_solr homepage](http://acts-as-solr.railsfreaks.com) is no more. For more up-to-date information, check out the project page of the current mainline on [GitHub](http://github.com/mattmatt/acts_as_solr/wikis).
0	95	\ No newline at end of file
...	...
...	...	@@ -0,0 +1,84 @@
	1	+= acts_as_solr Rails plugin
	2	+
	3	+This plugin adds full text search capabilities and many other nifty features from Apache's Solr[http://lucene.apache.org/solr/] to any Rails model.
	4	+It was based on the first draft by Erik Hatcher.
	5	+
	6	+== Current Release
	7	+
	8	+There is no numbered release yet, but the master branch is always considered stable.
	9	+
	10	+== Support
	11	+
	12	+Check the project website[http://mattmatt.github.com/acts_as_solr] or stop by the Google Group[http://groups.google.com/group/acts_as_solr]. Send bug reports through GitHub[http://github.com/mattmatt/acts_as_solr/issues].
	13	+
	14	+== Changes
	15	+
	16	+Please refer to the CHANGELOG[http://github.com/mattmatt/acts_as_solr/blob/master/CHANGE_LOG]
	17	+
	18	+== Installation
	19	+
	20	+For Rails >= 2.1:
	21	+
	22	+ script/plugin install git://github.com/mattmatt/acts_as_solr.git
	23	+
	24	+For Rails < 2.1:
	25	+
	26	+ cd vendor/plugins
	27	+ git clone git://github.com/mattmatt/acts_as_solr.git
	28	+ rm -rf acts_as_solr/.git
	29	+
	30	+Make sure you copy vendor/plugins/acts_as_solr/config/solr.yml to your Rails
	31	+application's config directory, when you install via git clone.
	32	+
	33	+== Requirements
	34	+
	35	+* Java Runtime Environment(JRE) 1.5 aka 5.0 [http://www.java.com/en/download/index.jsp](http://www.java.com/en/download/index.jsp)
	36	+* If you have libxml-ruby installed, make sure it's at least version 0.7
	37	+
	38	+== Configuration
	39	+
	40	+Basically everything is configured to work out of the box. You can use `rake solr:start` and `rake solr:stop`
	41	+to start and stop the Solr web server (an embedded Jetty). If the default JVM options aren't suitable for
	42	+your environment, you can configure them in solr.yml with the option `jvm_options`. There is a default
	43	+set for the production environment to have some more memory available for the JVM than the defaults, but
	44	+feel free to change them to your liking.
	45	+
	46	+== Basic Usage
	47	+
	48	+# Just include the line below to any of your ActiveRecord models:
	49	+ acts_as_solr
	50	+
	51	+# Or if you want, you can specify only the fields that should be indexed:
	52	+ acts_as_solr :fields => [:name, :author]
	53	+
	54	+# Then to find instances of your model, just do:
	55	+ Model.find_by_solr(query) #query is a string representing your query
	56	+
	57	+# Please see ActsAsSolr::ActsMethods for a complete info
	58	+
	59	+== acts_as_solr in your tests
	60	+
	61	+To test code that uses acts_as_solr you must start a Solr server for the test environment. You can do that with
	62	+
	63	+ rake solr:start RAILS_ENV=test
	64	+
	65	+However, if you would like to mock out Solr calls so that a Solr server is not needed (and your tests will run much faster), just add this to your `test_helper.rb` or similar:
	66	+
	67	+ class ActsAsSolr::Post
	68	+ def self.execute(request)
	69	+ true
	70	+ end
	71	+ end
	72	+
	73	+(via[http://www.subelsky.com/2007/10/actsassolr-capistranhttpwwwbloggercomim.html#c1646308013209805416])
	74	+
	75	+== Authors
	76	+
	77	+Erik Hatcher: First draft
	78	+Thiago Jackiw: Previous developer
	79	+Luke Francl: Current developer
	80	+Mathias Meyer: Current developer
	81	+
	82	+== Release Information
	83	+
	84	+Released under the MIT license.
0	85	\ No newline at end of file
...	...
...	...	@@ -0,0 +1,53 @@
	1	+require 'rubygems'
	2	+require 'rake'
	3	+require 'rake/testtask'
	4	+require 'rake/rdoctask'
	5	+
	6	+Dir["#{File.dirname(__FILE__)}/lib/tasks/*/.rake"].sort.each { \|ext\| load ext }
	7	+
	8	+desc "Default Task"
	9	+task :default => [:test]
	10	+
	11	+desc "Runs the unit tests"
	12	+task :test => "test:unit"
	13	+
	14	+namespace :test do
	15	+ task :setup do
	16	+ ENV['RAILS_ENV'] = "test"
	17	+ require File.dirname(__FILE__) + '/config/solr_environment'
	18	+ puts "Using " + DB
	19	+ %x(mysql -u#{MYSQL_USER} < #{File.dirname(__FILE__) + "/test/fixtures/db_definitions/mysql.sql"}) if DB == 'mysql'
	20	+
	21	+ Rake::Task["test:migrate"].invoke
	22	+ end
	23	+
	24	+ desc 'Measures test coverage using rcov'
	25	+ task :rcov => :setup do
	26	+ rm_f "coverage"
	27	+ rm_f "coverage.data"
	28	+ rcov = "rcov --rails --aggregate coverage.data --text-summary -Ilib"
	29	+
	30	+ system("#{rcov} --html #{Dir.glob('test/*/_test.rb').join(' ')}")
	31	+ system("open coverage/index.html") if PLATFORM['darwin']
	32	+ end
	33	+
	34	+ desc 'Runs the functional tests, testing integration with Solr'
	35	+ Rake::TestTask.new('functional' => :setup) do \|t\|
	36	+ t.pattern = "test/functional/*_test.rb"
	37	+ t.verbose = true
	38	+ end
	39	+
	40	+ desc "Unit tests"
	41	+ Rake::TestTask.new(:unit) do \|t\|
	42	+ t.libs << 'test/unit'
	43	+ t.pattern = "test/unit/*_shoulda.rb"
	44	+ t.verbose = true
	45	+ end
	46	+end
	47	+
	48	+Rake::RDocTask.new do \|rd\|
	49	+ rd.main = "README.rdoc"
	50	+ rd.rdoc_dir = "rdoc"
	51	+ rd.rdoc_files.exclude("lib/solr/*/.rb", "lib/solr.rb")
	52	+ rd.rdoc_files.include("README.rdoc", "lib/*/.rb")
	53	+end
0	54	\ No newline at end of file
...	...
...	...	@@ -0,0 +1,25 @@
	1	+acts_as_solr comes with a quick and fast unit test suite, and with a longer-running
	2	+functional test suite, the latter testing the actual integration with Solr.
	3	+
	4	+The unit test suite is written using Shoulda, so make sure you have a recent version
	5	+installed.
	6	+
	7	+Running `rake test` or just `rake` will run both test suites. Use `rake test:unit` to
	8	+just run the unit test suite.
	9	+
	10	+== How to run functional tests for this plugin:
	11	+To run the acts_as_solr's plugin tests run the following steps:
	12	+
	13	+- create a MySQL database called "actsassolr_test" (if you want to use MySQL)
	14	+
	15	+- create a new Rails project, if needed (the plugin can only be tested from within a Rails project); move/checkout acts_as_solr into its vendor/plugins/, as usual
	16	+
	17	+- copy vendor/plugins/acts_as_solr/config/solr.yml to config/ (the Rails config folder)
	18	+
	19	+- rake solr:start RAILS_ENV=test
	20	+
	21	+- rake test:functional (Accepts the following arguments: DB=sqlite\|mysql and MYSQL_USER=user)
	22	+
	23	+== Troubleshooting:
	24	+If for some reason the tests don't run and you get MySQL errors, make sure you edit the MYSQL_USER entry under
	25	+config/environment.rb. It's recommended to create or use a MySQL user with no password.
...	...
...	...	@@ -0,0 +1,15 @@
	1	+# Config file for the acts_as_solr plugin.
	2	+#
	3	+# If you change the host or port number here, make sure you update
	4	+# them in your Solr config file
	5	+
	6	+development:
	7	+ url: http://127.0.0.1:8982/solr
	8	+
	9	+production:
	10	+ url: http://127.0.0.1:8983/solr
	11	+ jvm_options: -server -d64 -Xmx1024M -Xms64M
	12	+
	13	+test:
	14	+ url: http://127.0.0.1:8981/solr
	15	+
...	...
...	...	@@ -0,0 +1,22 @@
	1	+ENV['RAILS_ENV'] = (ENV['RAILS_ENV'] \|\| 'development').dup
	2	+# RAILS_ROOT isn't defined yet, so figure it out.
	3	+rails_root_dir = "#{File.dirname(File.expand_path(__FILE__))}/../../../../"
	4	+SOLR_PATH = "#{File.dirname(File.expand_path(__FILE__))}/../solr" unless defined? SOLR_PATH
	5	+
	6	+SOLR_LOGS_PATH = "#{rails_root_dir}/log" unless defined? SOLR_LOGS_PATH
	7	+SOLR_PIDS_PATH = "#{rails_root_dir}/tmp/pids" unless defined? SOLR_PIDS_PATH
	8	+SOLR_DATA_PATH = "#{rails_root_dir}/solr/#{ENV['RAILS_ENV']}" unless defined? SOLR_DATA_PATH
	9	+
	10	+unless defined? SOLR_PORT
	11	+ config = YAML::load_file(rails_root_dir+'/config/solr.yml')
	12	+
	13	+ SOLR_PORT = ENV['PORT'] \|\| URI.parse(config[ENV['RAILS_ENV']]['url']).port
	14	+end
	15	+
	16	+SOLR_JVM_OPTIONS = config[ENV['RAILS_ENV']]['jvm_options'] unless defined? SOLR_JVM_OPTIONS
	17	+
	18	+if ENV['RAILS_ENV'] == 'test'
	19	+ DB = (ENV['DB'] ? ENV['DB'] : 'mysql') unless defined?(DB)
	20	+ MYSQL_USER = (ENV['MYSQL_USER'].nil? ? 'root' : ENV['MYSQL_USER']) unless defined? MYSQL_USER
	21	+ require File.join(File.dirname(File.expand_path(__FILE__)), '..', 'test', 'db', 'connections', DB, 'connection.rb')
	22	+end
...	...
...	...	@@ -0,0 +1,21 @@
	1	+# Copyright (c) 2006 Erik Hatcher, Thiago Jackiw
	2	+#
	3	+# Permission is hereby granted, free of charge, to any person obtaining a copy
	4	+# of this software and associated documentation files (the "Software"), to deal
	5	+# in the Software without restriction, including without limitation the rights
	6	+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
	7	+# copies of the Software, and to permit persons to whom the Software is
	8	+# furnished to do so, subject to the following conditions:
	9	+#
	10	+# The above copyright notice and this permission notice shall be included in all
	11	+# copies or substantial portions of the Software.
	12	+#
	13	+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
	14	+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
	15	+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
	16	+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
	17	+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
	18	+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
	19	+# SOFTWARE.
	20	+
	21	+require 'acts_as_solr'
0	22	\ No newline at end of file
...	...