onemorecloud-websolr-rails 1.1.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,15 @@
+*.log
+*.log
+*_pid
+coverage/*
+coverage.data
+solr/solr/data/*
+.svn
+test/db/*.db
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg
+*.gem
+doc

data/LICENSE

@@ -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.

data/README.rdoc

@@ -0,0 +1,69 @@
+
+= websolr-rails gem
+
+This gem provides Rails support for websolr.com, and a command-line tool to interact with 
+the indexes hosted there.  The Rails support is reverse-compatible with acts_as_solr.
+
+== RDoc
+
+Ruby documentation is at http://onemorecloud.github.com/websolr-rails
+
+== Current Release
+
+There is no numbered release yet, but the master branch is always considered stable.
+
+== Support
+
+For now, please send email to support@onemorecloud.com
+
+== Changes
+
+Please refer to the CHANGELOG[http://github.com/mattmatt/acts_as_solr/blob/master/CHANGE_LOG]
+
+== Installation
+
+$: gem sources -a http://gems.github.com
+$: sudo gem install onemorecloud-websolr-rails
+
+== Configuration
+
+$: export WEBSOLR_USER=my_username
+$: export WEBSOLR_PWD=my_password
+$: cd my_rails_project
+$: websolr add -n my_index_name
+$: websolr configure -e development -n my_index_name
+
+== 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
+
+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
+
+Websolr is by Onemorecloud.
+
+Based on acts_as_solr by: Erik Hatcher, Thiago Jackiw, Luke Francl, Mathias Meyer, and others.
+
+== Release Information
+
+Released under the MIT license.

data/Rakefile

@@ -0,0 +1,112 @@
+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
+
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "websolr-rails"
+    gem.summary = %Q{acts_as_solr compatible gem for websolr}
+    gem.description = %Q{acts_as_solr compatible gem for websolr}
+    gem.email = "kyle@kylemaxwell.com"
+    gem.homepage = "http://github.com/onemorecloud/websolr-rails"
+    gem.authors = ["Kyle Maxwell"]
+    gem.add_development_dependency "thoughtbot-shoulda"
+    gem.default_executable = %q{websolr}
+    gem.rdoc_options = ["--main", "README.rdoc", "README.rdoc", "lib"]
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/*_test.rb'
+  test.verbose = true
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'test/**/*_test.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+task :test => :check_dependencies
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "websolr-rails #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/TESTING_THE_PLUGIN

@@ -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.

data/VERSION

@@ -0,0 +1 @@
+1.1.1

data/bin/websolr

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + "/../lib/websolr_option_parser"
+require File.dirname(__FILE__) + "/../lib/websolr_controller"
+
+parser = WebsolrOptionParser.new
+parser.parse!
+controller = WebsolrController.new(parser)
+controller.start

data/config/solr.yml

@@ -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
+

data/config/solr_environment.rb

@@ -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

data/generate_rdoc.sh

@@ -0,0 +1,13 @@
+#!/bin/sh
+git clone git@github.com:onemorecloud/websolr-rails.git /tmp/websolr-rails  
+rm -rf /tmp/websolr-rails-rdoc                                          
+rdoc --op /tmp/websolr-rails-rdoc --main README.rdoc README.rdoc lib    
+cd /tmp/websolr-rails                                                   
+git checkout origin/gh-pages                                            
+git checkout -b gh-pages                                                
+git checkout gh-pages                                                   
+mv /tmp/websolr-rails-rdoc/* .                                          
+git add .                                                               
+git add -u                                                              
+git commit -m "updating rdoc"                                           
+git push origin gh-pages                                                

data/lib/acts_as_solr.rb

@@ -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

data/lib/acts_methods.rb

@@ -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