Rails 3 porting: bootstrap development environment

./script/quick-start runs back to back now You will notice that solr was removed.

Rails 3 porting: bootstrap development environment
./script/quick-start runs back to back now You will notice that solr was removed.
Antonio Terceiro
1 parent 2b84844f
Showing 188 changed files with 134 additions and 105843 deletions Show diff stats
MIGRATION_ISSUES
app/models/article.rb
app/models/blog_archives_block.rb
app/models/category.rb
app/models/certifier.rb
app/models/change_password.rb
app/models/enterprise.rb
app/models/environment.rb
app/models/license.rb
app/models/link_list_block.rb
app/models/my_network_block.rb
app/models/organization_mailing.rb
app/models/person.rb
app/models/product.rb
app/models/product_category.rb
app/models/products_block.rb
app/models/profile.rb
app/models/profile_image_block.rb
app/models/profile_list_block.rb
app/models/qualifier.rb
@@ -27,3 +27,5 @@
 * rewrite conditional routing. See FIXME in lib/route_if.rb and re-implement using the Rails 3 mechanism - http://guides.rubyonrails.org/routing.html#advanced-constraints
  
 * check FIXME's in config/environment.rb
+
+* xss_terminate sucks. We should replace it with the builtin mechanism in Rails 3
@@ -2,6 +2,8 @@ require &#39;hpricot&#39;
  
 class Article < ActiveRecord::Base
  
+  attr_accessible :name, :body, :abstract, :profile
+
   # use for internationalizable human type names in search facets
   # reimplement on subclasses
   def self.type_name
@@ -142,7 +144,6 @@ class Article &lt; ActiveRecord::Base
     else
       ArticleCategorization.add_category_to_article(c, self)
       self.categories(reload)
-      self.solr_save
     end
   end
  
@@ -160,7 +161,6 @@ class Article &lt; ActiveRecord::Base
       ArticleCategorization.add_category_to_article(item, self)
     end
     self.categories(true)
-    self.solr_save
     pending_categorizations.clear
   end
  
@@ -238,7 +238,6 @@ class Article &lt; ActiveRecord::Base
     body || ''
   end
  
-  include ApplicationHelper
   def reported_version(options = {})
     article = self
     search_path = File.join(Rails.root, 'app', 'views', 'shared', 'reported_versions')
@@ -469,10 +468,6 @@ class Article &lt; ActiveRecord::Base
     allow_post_content?(user) || user && allow_members_to_edit && user.is_member_of?(profile)
   end
  
-  def comments_updated
-    solr_save
-  end
-
   def accept_category?(cat)
     !cat.is_a?(ProductCategory)
   end
@@ -636,21 +631,6 @@ class Article &lt; ActiveRecord::Base
  
   private
  
-  # FIXME: workaround for development env.
-  # Subclasses aren't (re)loaded, and acts_as_solr
-  # depends on subclasses method to search
-  # see http://stackoverflow.com/questions/4138957/activerecordsubclassnotfound-error-when-using-sti-in-rails/4139245
-  UploadedFile
-  TextArticle
-  TinyMceArticle
-  TextileArticle
-  Folder
-  EnterpriseHomepage
-  Gallery
-  Blog
-  Forum
-  Event
-
   def self.f_type_proc(klass)
     klass.constantize.type_name
   end
@@ -682,9 +662,6 @@ class Article &lt; ActiveRecord::Base
   end
  
   delegate :region, :region_id, :environment, :environment_id, :to => :profile, :allow_nil => true
-  def name_sortable # give a different name for solr
-    name
-  end
  
   def public
     self.public?
@@ -694,39 +671,6 @@ class Article &lt; ActiveRecord::Base
     categories_including_virtual_ids
   end
  
-  public
-
-  acts_as_faceted :fields => {
-      :f_type => {:label => _('Type'), :proc => proc{|klass| f_type_proc(klass)}},
-      :f_published_at => {:type => :date, :label => _('Published date'), :queries => {'[* TO NOW-1YEARS/DAY]' => _("Older than one year"),
-        '[NOW-1YEARS TO NOW/DAY]' => _("In the last year"), '[NOW-1MONTHS TO NOW/DAY]' => _("In the last month"), '[NOW-7DAYS TO NOW/DAY]' => _("In the last week"), '[NOW-1DAYS TO NOW/DAY]' => _("In the last day")},
-        :queries_order => ['[NOW-1DAYS TO NOW/DAY]', '[NOW-7DAYS TO NOW/DAY]', '[NOW-1MONTHS TO NOW/DAY]', '[NOW-1YEARS TO NOW/DAY]', '[* TO NOW-1YEARS/DAY]']},
-      :f_profile_type => {:label => _('Profile'), :proc => proc{|klass| f_profile_type_proc(klass)}},
-      :f_category => {:label => _('Categories')},
-    }, :category_query => proc { |c| "category_filter:\"#{c.id}\"" },
-    :order => [:f_type, :f_published_at, :f_profile_type, :f_category]
-
-  acts_as_searchable :fields => facets_fields_for_solr + [
-      # searched fields
-      {:name => {:type => :text, :boost => 2.0}},
-      {:slug => :text}, {:body => :text},
-      {:abstract => :text}, {:filename => :text},
-      # filtered fields
-      {:public => :boolean}, {:environment_id => :integer},
-      {:profile_id => :integer}, :language,
-      {:category_filter => :integer},
-      # ordered/query-boosted fields
-      {:name_sortable => :string}, :last_changed_by_id, :published_at, :is_image,
-      :updated_at, :created_at,
-    ], :include => [
-      {:profile => {:fields => [:name, :identifier, :address, :nickname, :region_id, :lat, :lng]}},
-      {:comments => {:fields => [:title, :body, :author_name, :author_email]}},
-      {:categories => {:fields => [:name, :path, :slug, :lat, :lng, :acronym, :abbreviation]}},
-    ], :facets => facets_option_for_solr,
-    :boost => proc { |a| 10 if a.profile && a.profile.enabled },
-    :if => proc{ |a| ! ['RssFeed'].include?(a.class.name) }
-  handle_asynchronously :solr_save
-
   private
  
   def sanitize_tag_list
@@ -2,7 +2,7 @@ class BlogArchivesBlock &lt; Block
  
   include ActionView::Helpers::TagHelper
   include ActionView::Helpers::UrlHelper
-  include ActionController::UrlWriter
+  include Rails.application.routes.url_helpers
   include ActionView::Helpers::AssetTagHelper
   include DatesHelper
  
@@ -90,23 +90,4 @@ class Category &lt; ActiveRecord::Base
     self.children.find(:all, :conditions => {:display_in_menu => true}).empty?
   end
  
-  private
-  def name_sortable # give a different name for solr
-    name
-  end
-  public
-
-  acts_as_searchable :fields => [
-    # searched fields
-    {:name => {:type => :text, :boost => 2.0}},
-    {:path => :text}, {:slug => :text},
-    {:abbreviation => :text}, {:acronym => :text},
-    # filtered fields
-    :parent_id,
-    # ordered/query-boosted fields
-    {:name_sortable => :string},
-  ]
-  after_save_reindex [:articles, :profiles], :with => :delayed_job
-  handle_asynchronously :solr_save
-
 end
@@ -24,6 +24,4 @@ class Certifier &lt; ActiveRecord::Base
     self.name.downcase.transliterate <=> b.name.downcase.transliterate
   end
  
-  after_save_reindex [:products], :with => :delayed_job
-
 end
@@ -80,7 +80,7 @@ class ChangePassword &lt; Task
     _('Your password was changed successfully.')
   end
  
-  include ActionController::UrlWriter
+  include Rails.application.routes.url_helpers
   def task_created_message
     hostname = self.requestor.environment.default_hostname
     code = self.code
@@ -14,7 +14,6 @@ class Enterprise &lt; Organization
  
   has_and_belongs_to_many :fans, :class_name => 'Person', :join_table => 'favorite_enteprises_people'
  
-  after_save_reindex [:products], :with => :delayed_job
   extra_data_for_index :product_categories
   def product_categories
     products.includes(:product_category).map{|p| p.category_full_name}.compact
@@ -764,18 +764,49 @@ class Environment &lt; ActiveRecord::Base
   after_create :create_templates
  
   def create_templates
-    pre = self.name.to_slug + '_'
-    ent_id = Enterprise.create!(:name => 'Enterprise template', :identifier => pre + 'enterprise_template', :environment => self, :visible => false, :is_template => true).id
-    inactive_enterprise_tmpl = Enterprise.create!(:name => 'Inactive Enterprise template', :identifier => pre + 'inactive_enterprise_template', :environment => self, :visible => false, :is_template => true)
-    com_id = Community.create!(:name => 'Community template', :identifier => pre + 'community_template', :environment => self, :visible => false, :is_template => true).id
+    prefix = self.name.to_slug + '_'
+
+    enterprise_template = Enterprise.new(
+      :name => 'Enterprise template',
+      :identifier => prefix + 'enterprise_template'
+    )
+
+    inactive_enterprise_template = Enterprise.new(
+      :name => 'Inactive Enterprise template',
+      :identifier => prefix + 'inactive_enterprise_template'
+    )
+
+    community_template = Community.new(
+      :name => 'Community template',
+      :identifier => prefix + 'community_template'
+    )
+
+    [
+      enterprise_template,
+      inactive_enterprise_template,
+      community_template
+    ].each do |profile|
+      profile.is_template = true
+      profile.visible = false
+      profile.environment = self
+      profile.save!
+    end
+
     pass = Digest::MD5.hexdigest rand.to_s
-    user = User.create!(:login => (pre + 'person_template'), :email => (pre + 'template@template.noo'), :password => pass, :password_confirmation => pass, :environment => self).person
-    user.update_attributes(:visible => false, :name => "Person template", :is_template => true)
-    usr_id = user.id
-    self.settings[:enterprise_template_id] = ent_id
-    self.inactive_enterprise_template = inactive_enterprise_tmpl
-    self.settings[:community_template_id] = com_id
-    self.settings[:person_template_id] = usr_id
+    user = User.new(:login => (prefix + 'person_template'), :email => (prefix + 'template@template.noo'), :password => pass, :password_confirmation => pass)
+    user.environment = self
+    user.save!
+
+    person_template = user.person
+    person_template.name = "Person template"
+    person_template.is_template = true
+    person_template.visible = false
+    person_template.save!
+
+    self.enterprise_template = enterprise_template
+    self.inactive_enterprise_template = inactive_enterprise_template
+    self.community_template = community_template
+    self.person_template = person_template
     self.save!
   end
  
@@ -788,14 +819,20 @@ class Environment &lt; ActiveRecord::Base
  
   after_create :create_default_licenses
   def create_default_licenses
-    License.create!(:name => 'CC (by)', :url => 'http://creativecommons.org/licenses/by/3.0/legalcode', :environment => self)
-    License.create!(:name => 'CC (by-nd)', :url => 'http://creativecommons.org/licenses/by-nd/3.0/legalcode', :environment => self)
-    License.create!(:name => 'CC (by-sa)', :url => 'http://creativecommons.org/licenses/by-sa/3.0/legalcode', :environment => self)
-    License.create!(:name => 'CC (by-nc)', :url => 'http://creativecommons.org/licenses/by-nc/3.0/legalcode', :environment => self)
-    License.create!(:name => 'CC (by-nc-nd)', :url => 'http://creativecommons.org/licenses/by-nc-nd/3.0/legalcode', :environment => self)
-    License.create!(:name => 'CC (by-nc-sa)', :url => 'http://creativecommons.org/licenses/by-nc-sa/3.0/legalcode', :environment => self)
-    License.create!(:name => 'Free Art', :url => 'http://artlibre.org/licence/lal/en', :environment => self)
-    License.create!(:name => 'GNU FDL', :url => 'http://www.gnu.org/licenses/fdl-1.3.txt', :environment => self)
+    [
+      { :name => 'CC (by)', :url => 'http://creativecommons.org/licenses/by/3.0/legalcode'},
+      { :name => 'CC (by-nd)', :url => 'http://creativecommons.org/licenses/by-nd/3.0/legalcode'},
+      { :name => 'CC (by-sa)', :url => 'http://creativecommons.org/licenses/by-sa/3.0/legalcode'},
+      { :name => 'CC (by-nc)', :url => 'http://creativecommons.org/licenses/by-nc/3.0/legalcode'},
+      { :name => 'CC (by-nc-nd)', :url => 'http://creativecommons.org/licenses/by-nc-nd/3.0/legalcode'},
+      { :name => 'CC (by-nc-sa)', :url => 'http://creativecommons.org/licenses/by-nc-sa/3.0/legalcode'},
+      { :name => 'Free Art', :url => 'http://artlibre.org/licence/lal/en'},
+      { :name => 'GNU FDL', :url => 'http://www.gnu.org/licenses/fdl-1.3.txt'},
+    ].each do |data|
+      license = License.new(data)
+      license.environment = self
+      license.save!
+    end
   end
  
   def highlighted_products_with_image(options = {})
 class License < ActiveRecord::Base
+
+  attr_accessible :name, :url
+
   belongs_to :environment
   has_many :content, :class_name => 'Article', :foreign_key => 'license_id'
  
 class LinkListBlock < Block
  
+  attr_accessible :links
+
   ICONS = [
     ['no-icon', _('(No icon)')],
     ['edit', N_('Edit')],
 class MyNetworkBlock < Block
  
-  include ActionController::UrlWriter
+  include Rails.application.routes.url_helpers
  
   def self.description
     _('My network')
@@ -23,7 +23,7 @@ class OrganizationMailing &lt; Mailing
     _('Sent by community %s.') % source.name
   end
  
-  include ActionController::UrlWriter
+  include Rails.application.routes.url_helpers
   def url
     url_for(source.url)
   end
@@ -8,20 +8,6 @@ class Person &lt; Profile
   acts_as_trackable :after_add => Proc.new {|p,t| notify_activity(t)}
   acts_as_accessor
  
-  @@human_names = {}
-
-  def self.human_names
-    @@human_names
-  end
-
-  # FIXME ugly workaround
-  def self.human_attribute_name(attrib)
-    human_names.each do |key, human_text|
-      return human_text if attrib.to_sym == key.to_sym
-    end
-    super
-  end
-
   scope :members_of, lambda { |resources|
     resources = [resources] if !resources.kind_of?(Array)
     conditions = resources.map {|resource| "role_assignments.resource_type = '#{resource.class.base_class.name}' AND role_assignments.resource_id = #{resource.id || -1}"}.join(' OR ')
@@ -192,7 +192,7 @@ class Product &lt; ActiveRecord::Base
     self.enterprise.environment.production_costs + self.enterprise.production_costs
   end
  
-  include ActionController::UrlWriter
+  include Rails.application.routes.url_helpers
   def price_composition_bar_display_url
     url_for({:host => enterprise.default_hostname, :controller => 'manage_products', :action => 'display_price_composition_bar', :profile => enterprise.identifier, :id => self.id }.merge(Noosfero.url_options))
   end
@@ -245,9 +245,7 @@ class Product &lt; ActiveRecord::Base
  
   alias_method :name_sortable, :name
   delegate :enabled, :region, :region_id, :environment, :environment_id, :to => :enterprise
-  def name_sortable # give a different name for solr
-    name
-  end
+
   def public
     self.public?
   end
@@ -257,47 +255,5 @@ class Product &lt; ActiveRecord::Base
   def category_filter
     enterprise.categories_including_virtual_ids << product_category_id
   end
-  public
-
-  acts_as_faceted :fields => {
-      :f_category => {:label => _('Related products')},
-      :f_region => {:label => _('City'), :proc => proc { |id| f_region_proc(id) }},
-      :f_qualifier => {:label => _('Qualifiers'), :proc => proc { |id| f_qualifier_proc(id) }},
-    }, :category_query => proc { |c| "category_filter:#{c.id}" },
-    :order => [:f_category, :f_region, :f_qualifier]
-
-  Boosts = [
-    [:image, 0.55, proc{ |p| p.image ? 1 : 0}],
-    [:qualifiers, 0.45, proc{ |p| p.product_qualifiers.count > 0 ? 1 : 0}],
-    [:open_price, 0.45, proc{ |p| p.price_described? ? 1 : 0}],
-    [:solidarity, 0.45, proc{ |p| p.percentage_from_solidarity_economy[0].to_f/100 }],
-    [:available, 0.35, proc{ |p| p.available ? 1 : 0}],
-    [:price, 0.35, proc{ |p| (!p.price.nil? and p.price > 0) ? 1 : 0}],
-    [:new_product, 0.35, proc{ |p| (p.updated_at.to_i - p.created_at.to_i) < 24*3600 ? 1 : 0}],
-    [:description, 0.3, proc{ |p| !p.description.blank? ? 1 : 0}],
-    [:enabled, 0.2, proc{ |p| p.enterprise.enabled ? 1 : 0}],
-  ]
-
-  acts_as_searchable :fields => facets_fields_for_solr + [
-      # searched fields
-      {:name => {:type => :text, :boost => 2.0}},
-      {:description => :text}, {:category_full_name => :text},
-      # filtered fields
-      {:public => :boolean}, {:environment_id => :integer},
-      {:enabled => :boolean}, {:category_filter => :integer},
-      # ordered/query-boosted fields
-      {:price_sortable => :decimal}, {:name_sortable => :string},
-      {:lat => :float}, {:lng => :float},
-      :updated_at, :created_at,
-    ], :include => [
-      {:product_category => {:fields => [:name, :path, :slug, :lat, :lng, :acronym, :abbreviation]}},
-      {:region => {:fields => [:name, :path, :slug, :lat, :lng]}},
-      {:enterprise => {:fields => [:name, :identifier, :address, :nickname, :lat, :lng]}},
-      {:qualifiers => {:fields => [:name]}},
-      {:certifiers => {:fields => [:name]}},
-    ], :facets => facets_option_for_solr,
-    :boost => proc{ |p| boost = 1; Boosts.each{ |b| boost = boost * (1 - ((1 - b[2].call(p)) * b[1])) }; boost}
-  handle_asynchronously :solr_save
-  after_save_reindex [:enterprise], :with => :delayed_job
  
 end
@@ -11,6 +11,4 @@ class ProductCategory &lt; Category
     top_category ? top_category.children : top_level_for(env).select{|c|c.kind_of?(ProductCategory)}
   end
  
-  after_save_reindex [:products], :with => :delayed_job
-
 end
@@ -2,7 +2,7 @@ class ProductsBlock &lt; Block
  
   include ActionView::Helpers::TagHelper
   include ActionView::Helpers::UrlHelper
-  include ActionController::UrlWriter
+  include Rails.application.routes.url_helpers
  
   def self.description
     _('Products')
@@ -3,6 +3,8 @@
 # which by default is the one returned by Environment:default.
 class Profile < ActiveRecord::Base
  
+  attr_accessible :name, :identifier
+
   # use for internationalizable human type names in search facets
   # reimplement on subclasses
   def self.type_name
@@ -117,11 +119,6 @@ class Profile &lt; ActiveRecord::Base
  
   has_many :comments_received, :class_name => 'Comment', :through => :articles, :source => :comments
  
-  # FIXME ugly workaround
-  def self.human_attribute_name(attrib)
-      _(self.superclass.human_attribute_name(attrib))
-  end
-
   def scraps(scrap=nil)
     scrap = scrap.is_a?(Scrap) ? scrap.id : scrap
     scrap.nil? ? Scrap.all_scraps(self) : Scrap.all_scraps(self).find(scrap)
@@ -258,7 +255,6 @@ class Profile &lt; ActiveRecord::Base
     else
       ProfileCategorization.add_category_to_profile(c, self)
       self.categories(true)
-      self.solr_save
     end
     self.categories(reload)
   end
@@ -927,46 +923,14 @@ private :generate_url, :url_options
     self.enabled
   end
  
-  def name_sortable # give a different name for solr
-    name
-  end
   def public
     self.public?
   end
   def category_filter
     categories_including_virtual_ids
   end
-  public
  
-  acts_as_faceted :fields => {
-      :f_enabled => {:label => _('Situation'), :type_if => proc { |klass| klass.kind_of?(Enterprise) },
-        :proc => proc { |id| f_enabled_proc(id) }},
-      :f_region => {:label => _('City'), :proc => proc { |id| f_region_proc(id) }},
-      :f_categories => {:multi => true, :proc => proc {|facet, id| f_categories_proc(facet, id)},
-        :label => proc { |env| f_categories_label_proc(env) }, :label_abbrev => proc{ |env| f_categories_label_abbrev_proc(env) }},
-    }, :category_query => proc { |c| "category_filter:#{c.id}" },
-    :order => [:f_region, :f_categories, :f_enabled]
-
-  acts_as_searchable :fields => facets_fields_for_solr + [:extra_data_for_index,
-      # searched fields
-      {:name => {:type => :text, :boost => 2.0}},
-      {:identifier => :text}, {:nickname => :text},
-      # filtered fields
-      {:public => :boolean}, {:environment_id => :integer},
-      {:category_filter => :integer},
-      # ordered/query-boosted fields
-      {:name_sortable => :string}, {:user_id => :integer},
-      :enabled, :active, :validated, :public_profile,
-      {:lat => :float}, {:lng => :float},
-      :updated_at, :created_at,
-    ],
-    :include => [
-      {:region => {:fields => [:name, :path, :slug, :lat, :lng]}},
-      {:categories => {:fields => [:name, :path, :slug, :lat, :lng, :acronym, :abbreviation]}},
-    ], :facets => facets_option_for_solr,
-    :boost => proc{ |p| 10 if p.enabled }
-  after_save_reindex [:articles], :with => :delayed_job
-  handle_asynchronously :solr_save
+  public
  
   def control_panel_settings_button
     {:title => _('Profile Info and settings'), :icon => 'edit-profile'}
 class ProfileImageBlock < Block
  
+  attr_accessible :show_name
+
   settings_items :show_name, :type => :boolean, :default => false
  
   def self.description
 class ProfileListBlock < Block
  
+  attr_accessible :limit, :prioritize_profiles_with_image
+
   settings_items :limit, :type => :integer, :default => 6
   settings_items :prioritize_profiles_with_image, :type => :boolean, :default => true
  
@@ -15,6 +15,4 @@ class Qualifier &lt; ActiveRecord::Base
     self.name.downcase.transliterate <=> b.name.downcase.transliterate
   end
  
-  after_save_reindex [:products], :with => :delayed_job
-
 end
@@ -14,7 +14,7 @@ class RecentDocumentsBlock &lt; Block
  
   settings_items :limit, :type => :integer, :default => 5
  
-  include ActionController::UrlWriter
+  include Rails.application.routes.url_helpers
   def content(args={})
     docs = self.limit.nil? ? owner.recent_documents(nil, {}, false) : owner.recent_documents(self.limit, {}, false)
     block_title(title) +
@@ -63,7 +63,7 @@ class RssFeed &lt; Article
     'text/xml'
   end
  
-  include ActionController::UrlWriter
+  include Rails.application.routes.url_helpers
   def fetch_articles
     if parent && parent.has_posts?
       language = self.language.blank? ? {} : { :language => self.language }
@@ -2,7 +2,7 @@ class TagsBlock &lt; Block
  
   include TagsHelper
   include BlockHelper
-  include ActionController::UrlWriter
+  include Rails.application.routes.url_helpers
  
   settings_items :limit, :type => :integer, :default => 12
  
 require 'digest/sha1'
+require 'user_activation_job'
  
 # User models the system users, and is generated by the acts_as_authenticated
 # Rails generator.
 class User < ActiveRecord::Base
  
+  attr_accessible :login, :email, :password, :password_confirmation
+
   N_('Password')
   N_('Password confirmation')
   N_('Terms accepted')
@@ -15,9 +18,12 @@ class User &lt; ActiveRecord::Base
   # FIXME ugly workaround
   def self.human_attribute_name(attrib)
     case attrib.to_sym
-      when :login:  return _('Username')
-      when :email:  return _('e-Mail')
-      else _(self.superclass.human_attribute_name(attrib))
+      when :login
+        return _('Username')
+      when :email
+        return _('e-Mail')
+      else
+        _(self.superclass.human_attribute_name(attrib))
     end
   end
  
@@ -29,11 +35,18 @@ class User &lt; ActiveRecord::Base
   end
  
   after_create do |user|
-    user.person ||= Person.new
-    user.person.attributes = user.person_data.merge(:identifier => user.login, :user => user, :environment_id => user.environment_id)
-    user.person.name ||= user.login
-    user.person.visible = false unless user.activated?
-    user.person.save!
+    unless user.person
+      p = Person.new
+
+      p.attributes = user.person_data
+      p.identifier = user.login
+      p.user = user
+      p.environment = user.environment
+      p.name ||= user.login
+      p.visible = false unless user.activated?
+
+      user.person = p
+    end
     if user.environment.enabled?('skip_new_user_email_confirmation')
       user.activate
     end
@@ -51,6 +64,8 @@ class User &lt; ActiveRecord::Base
   end
  
   class Mailer < ActionMailer::Base
+
+    # FIXME use new ActionMailer API here
     def activation_email_notify(user)
       user_email = "#{user.login}@#{user.email_domain}"
       recipients user_email
@@ -64,16 +79,19 @@ class User &lt; ActiveRecord::Base
     end
  
     def activation_code(user)
-      recipients user.email
-
-      from "#{user.environment.name} <#{user.environment.contact_email}>"
-      subject _("[%s] Activate your account") % [user.environment.name]
-      body :recipient => user.name,
-        :activation_code => user.activation_code,
-        :environment => user.environment.name,
-        :url => user.environment.top_url
+      @recipient = user.name,
+      @activation_code = user.activation_code
+      @environment = user.environment.name
+      @url = user.environment.top_url
+
+      mail(
+        :from => "#{user.environment.name} <#{user.environment.contact_email}>",
+        :to => user.email,
+        :subject => _("[%s] Activate your account") % [user.environment.name],
+      )
     end
  
+    # FIXME use new ActionMailer API here
     def signup_welcome_email(user)
       email_body = user.environment.signup_welcome_text_body.gsub('{user_name}', user.name)
       email_subject = user.environment.signup_welcome_text_subject
@@ -93,7 +111,7 @@ class User &lt; ActiveRecord::Base
       self.person.save!
     end
   end
-  
+
   has_one :person, :dependent => :destroy
   belongs_to :environment
  
@@ -136,6 +154,7 @@ class User &lt; ActiveRecord::Base
       false
     else
       if environment.enabled?('send_welcome_email_to_new_users') && environment.has_signup_welcome_text?
+        # FIXME use new ActionMailer API here
         User::Mailer.delay.deliver_signup_welcome_email(self)
       end
       true
@@ -329,7 +348,7 @@ class User &lt; ActiveRecord::Base
  
     def deliver_activation_code
       return if person.is_template?
-      User::Mailer.deliver_activation_code(self) unless self.activation_code.blank?
+      User::Mailer.activation_code(self).deliver unless self.activation_code.blank?
     end
  
     def delay_activation_check
 # locally-developed modules
-require 'acts_as_faceted'
 require 'acts_as_filesystem'
 require 'acts_as_having_settings'
-require 'acts_as_searchable'
 require 'acts_as_having_boxes'
 require 'acts_as_having_image'
 require 'acts_as_having_posts'
@@ -11,6 +9,7 @@ require &#39;maybe_add_http&#39;
 require 'set_profile_region_from_city_state'
 require 'authenticated_system'
 require 'needs_profile'
+require 'white_list_filter'
  
 # third-party libraries
 require 'will_paginate'
@@ -2,8 +2,9 @@
  
 # Disable Rails html autoescaping. This is due to noosfero using too much helpers/models to output html.
 # It it would change too much code and make it hard to maintain.
+# FIXME THIS IS SO WRONG
 class Object
   def html_safe?
     true
   end
-end
 \ No newline at end of file
+end
@@ -1,222 +0,0 @@
-module ActsAsFaceted
-
-  module ClassMethods
-  end
-
-  module ActsMethods
-    # Example:
-    #
-    #acts_as_faceted :fields => {
-    #  :f_type => {:label => _('Type'), :proc => proc{|klass| f_type_proc(klass)}},
-    #  :f_published_at => {:type => :date, :label => _('Published date'), :queries => {'[* TO NOW-1YEARS/DAY]' => _("Older than one year"),
-    #    '[NOW-1YEARS TO NOW/DAY]' => _("Last year"), '[NOW-1MONTHS TO NOW/DAY]' => _("Last month"), '[NOW-7DAYS TO NOW/DAY]' => _("Last week"), '[NOW-1DAYS TO NOW/DAY]' => _("Last day")}},
-    #  :f_profile_type => {:label => _('Author'), :proc => proc{|klass| f_profile_type_proc(klass)}},
-    #  :f_category => {:label => _('Categories')}},
-    #  :order => [:f_type, :f_published_at, :f_profile_type, :f_category]
-    #
-    #acts_as_searchable :additional_fields => [ {:name => {:type => :string, :as => :name_sort, :boost => 5.0}} ] + facets_fields_for_solr,
-    #  :exclude_fields => [:setting],
-    #  :include => [:profile],
-    #  :facets => facets_option_for_solr,
-    #  :if => proc{|a| ! ['RssFeed'].include?(a.class.name)}
-    def acts_as_faceted(options)
-      extend ClassMethods
-      extend ActsAsSolr::CommonMethods
-
-      cattr_accessor :facets
-      cattr_accessor :facets_order
-      cattr_accessor :to_solr_fields_names
-      cattr_accessor :facets_results_containers
-      cattr_accessor :solr_fields_names
-      cattr_accessor :facets_option_for_solr
-      cattr_accessor :facets_fields_for_solr
-      cattr_accessor :facet_category_query
-
-      self.facets = options[:fields]
-      self.facets_order = options[:order] || self.facets.keys
-      self.facets_results_containers = {:fields => 'facet_fields', :queries => 'facet_queries', :ranges => 'facet_ranges'}
-      self.facets_option_for_solr = Hash[facets.select{ |id,data| ! data.has_key?(:queries) }].keys
-      self.facets_fields_for_solr = facets.map{ |id,data| {id => data[:type] || :facet} }
-      self.solr_fields_names = facets.map{ |id,data| id.to_s + '_' + get_solr_field_type(data[:type] || :facet) }
-      self.facet_category_query = options[:category_query]
-
-      # A hash to retrieve the field key for the solr facet string returned
-      # :field_name => "field_name_facet"
-      self.to_solr_fields_names = Hash[facets.keys.zip(solr_fields_names)]
-
-      def facet_by_id(id)
-        {:id => id}.merge(facets[id]) if facets[id]
-      end
-
-      def map_facets_for(environment)
-        facets_order.map do |id|
-          facet = facet_by_id(id)
-          next if facet[:type_if] and !facet[:type_if].call(self.new)
-
-          if facet[:multi]
-            facet[:label].call(environment).map do |label_id, label|
-              facet.merge({:id => facet[:id].to_s+'_'+label_id.to_s, :solr_field => facet[:id], :label_id => label_id, :label => label})
-            end
-          else
-            facet.merge(:id => facet[:id].to_s, :solr_field => facet[:id])
-          end
-        end.compact.flatten
-      end
-
-      def map_facet_results(facet, facet_params, facets_data, unfiltered_facets_data = {}, options = {})
-        raise 'Use map_facets_for before this method' if facet[:solr_field].nil?
-        facets_data = {} if facets_data.blank? # could be empty array
-        solr_facet = to_solr_fields_names[facet[:solr_field]]
-        unfiltered_facets_data ||= {}
-
-        if facet[:queries]
-          container = facets_data[facets_results_containers[:queries]]
-          facet_data = (container.nil? or container.empty?) ? [] : container.select{ |k,v| k.starts_with? solr_facet }
-          container = unfiltered_facets_data[facets_results_containers[:queries]]
-          unfiltered_facet_data = (container.nil? or container.empty?) ? [] : container.select{ |k,v| k.starts_with? solr_facet }
-        else
-          container = facets_data[facets_results_containers[:fields]]
-          facet_data = (container.nil? or container.empty?) ? [] : container[solr_facet] || []
-          container = unfiltered_facets_data[facets_results_containers[:fields]]
-          unfiltered_facet_data = (container.nil? or container.empty?) ? [] : container[solr_facet] || []
-        end
-
-        if !unfiltered_facets_data.blank? and !facet_params.blank?
-          f = Hash[Array(facet_data)]
-          zeros = []
-          facet_data = unfiltered_facet_data.map do |id, count|
-            count = f[id]
-            if count.nil?
-              zeros.push [id, 0]
-              nil
-            else
-              [id, count]
-            end
-          end.compact + zeros
-        end
-
-        facet_count = facet_data.length
-
-        if facet[:queries]
-          result = facet_data.map do |id, count|
-            q = id[id.index(':')+1,id.length]
-            label = facet_result_name(facet, q)
-            [q, label, count] if count > 0
-          end.compact
-          result = facet[:queries_order].map{ |id| result.detect{ |rid, label, count| rid == id } }.compact if facet[:queries_order]
-        elsif facet[:proc]
-          if facet[:label_id]
-            result = facet_data.map do |id, count|
-              name = facet_result_name(facet, id)
-              [id, name, count] if name
-            end.compact
-            # FIXME limit is NOT improving performance in this case :(
-            facet_count = result.length
-            result = result.first(options[:limit]) if options[:limit]
-          else
-            facet_data = facet_data.first(options[:limit]) if options[:limit]
-            result = facet_data.map { |id, count| [id, facet_result_name(facet, id), count] }
-          end
-        else
-          facet_data = facet_data.first(options[:limit]) if options[:limit]
-          result = facet_data.map { |id, count| [id, facet_result_name(facet, id), count] }
-        end
-
-        sorted = facet_result_sort(facet, result, options[:sort])
-
-        # length can't be used if limit option is given;
-        # total_entries comes to help
-        sorted.class.send(:define_method, :total_entries, proc { facet_count })
-
-        sorted
-      end
-
-      def facet_result_sort(facet, facets_data, sort_by = nil)
-        if facet[:queries_order]
-          facets_data
-        elsif sort_by == :alphabetically
-          facets_data.sort{ |a,b| Array(a[1])[0] <=> Array(b[1])[0] }
-        elsif sort_by == :count
-          facets_data.sort{ |a,b| -1*(a[2] <=> b[2]) }
-        else
-          facets_data
-        end
-      end
-
-      def facet_result_name(facet, data)
-        if facet[:queries]
-          gettext(facet[:queries][data])
-        elsif facet[:proc]
-          if facet[:multi]
-            facet[:label_id] ||= 0
-            facet[:proc].call(facet, data)
-          else
-            gettext(facet[:proc].call(data))
-          end
-        else
-          data
-        end
-      end
-
-      def facet_label(facet)
-        return nil unless facet
-        _(facet[:label])
-      end
-
-      def facets_find_options(facets_selected = {}, options = {})
-        browses = []
-        facets_selected ||= {}
-        facets_selected.map do |id, value|
-          next unless facets[id.to_sym]
-          if value.kind_of?(Hash)
-            value.map do |label_id, value|
-              value.to_a.each do |value|
-                browses << id.to_s + ':' + (facets[id.to_sym][:queries] ? value : '"'+value.to_s+'"')
-              end
-            end
-          else
-            browses << id.to_s + ':' + (facets[id.to_sym][:queries] ? value : '"'+value.to_s+'"')
-          end
-        end.flatten
-
-        {:facets => {:zeros => false, :sort => :count,
-            :fields => facets_option_for_solr,
-            :browse => browses,
-            :query => facets.map { |f, options| options[:queries].keys.map { |q| f.to_s + ':' + q } if options[:queries] }.compact.flatten,
-          }
-        }
-      end
-    end
-  end
-
-end
-
-ActiveRecord::Base.extend ActsAsFaceted::ActsMethods
-
-# from https://github.com/rubyworks/facets/blob/master/lib/core/facets/enumerable/graph.rb
-module Enumerable
-  def graph(&yld)
-    if yld
-      h = {}
-      each do |*kv|
-        r = yld[*kv]
-        case r
-        when Hash
-          nk, nv = *r.to_a[0]
-        when Range
-          nk, nv = r.first, r.last
-        else
-          nk, nv = *r
-        end
-        h[nk] = nv
-      end
-      h
-    else
-      Enumerator.new(self,:graph)
-    end
-  end
-
-  # Alias for #graph, which stands for "map hash".
-  alias_method :mash, :graph
-end
-
@@ -1,87 +0,0 @@
-module ActsAsSearchable
-
-  module ClassMethods
-    ACTS_AS_SEARCHABLE_ENABLED = true unless defined? ACTS_AS_SEARCHABLE_ENABLED
-
-    def acts_as_searchable(options = {})
-      return if !ACTS_AS_SEARCHABLE_ENABLED
-
-      if options[:fields]
-        options[:fields] << {:schema_name => :string}
-      else
-        options[:additional_fields] ||= []
-        options[:additional_fields] << {:schema_name => :string}
-      end
-
-      acts_as_solr options
-      extend FindByContents
-      send :include, InstanceMethods
-    end
-
-    module InstanceMethods
-      def schema_name
-        self.class.schema_name
-      end
-
-      # replace solr_id from vendor/plugins/acts_as_solr_reloaded/lib/acts_as_solr/instance_methods.rb
-      # to include schema_name
-      def solr_id
-         id = "#{self.class.name}:#{record_id(self)}"
-         id.insert(0, "#{schema_name}:") unless schema_name.blank?
-         id
-      end
-    end
-
-    module FindByContents
-
-      def schema_name
-        (Noosfero::MultiTenancy.on? and ActiveRecord::Base.postgresql?) ? ActiveRecord::Base.connection.schema_search_path : ''
-      end
-
-      def find_by_contents(query, pg_options = {}, options = {}, db_options = {})
-        pg_options[:page] ||= 1
-        pg_options[:per_page] ||= 20
-        options[:page] = pg_options[:page].to_i
-        options[:per_page] = pg_options[:per_page].to_i
-        options[:scores] ||= true
-        options[:filter_queries] ||= []
-        options[:filter_queries] << "schema_name:\"#{schema_name}\"" unless schema_name.blank?
-        all_facets_enabled = options.delete(:all_facets)
-        options[:per_page] = options.delete(:extra_limit) if options[:extra_limit]
-        results = []
-        facets = all_facets = {}
-
-        solr_result = find_by_solr(query, options)
-        if all_facets_enabled
-          options[:facets][:browse] = nil
-          all_facets = find_by_solr(query, options.merge(:per_page => 0)).facets
-        end
-
-        if !solr_result.nil?
-          facets = options.include?(:facets) ? solr_result.facets : []
-
-          if db_options.empty?
-            results = solr_result
-          else
-            ids = solr_result.results.map{ |r| r[:id].to_i }
-            if ids.empty?
-              ids << -1
-            end
-
-            if db_options[:conditions]
-              db_options[:conditions] = sanitize_sql_for_conditions(db_options[:conditions]) + " and #{table_name}.id in (#{ids.join(', ')})"
-            else
-              db_options[:conditions] = "#{table_name}.id in (#{ids.join(', ')})"
-            end
-
-            results = find(:all, db_options)
-          end
-        end
-
-        {:results => results, :facets => facets, :all_facets => all_facets}
-      end
-    end
-  end
-end
-
-ActiveRecord::Base.send(:extend, ActsAsSearchable::ClassMethods)
 namespace :db do
   namespace :data do
     task :minimal do
-      sh './script/runner', "Environment.create!(:name => 'Noosfero', :is_default => true)"
+      sh 'rails', 'runner', "Environment.create!(:name => 'Noosfero', :is_default => true)"
       unless ENV['NOOSFERO_DOMAIN'].blank?
-        sh './script/runner', "Environment.default.domains << Domain.new(:name => ENV['NOOSFERO_DOMAIN'])"
+        sh 'rails', 'runner', "Environment.default.domains << Domain.new(:name => ENV['NOOSFERO_DOMAIN'])"
       end
     end
   end
@@ -66,15 +66,6 @@ else
   fi
 fi
  
-# setup solr
-run 'rake solr:download || true'
-if ! test -f vendor/plugins/acts_as_solr_reloaded/solr/start.jar; then
-  complain "Failed to download solr!"
-  exit 1
-fi
-
-run cp config/solr.yml.dist config/solr.yml
-
 # create the database with sample data
 run cp config/database.yml.sqlite3 config/database.yml
 run rake db:schema:load
 class Role < ActiveRecord::Base
  
+  attr_accessible :key, :name, :environment, :permissions
+
   has_many :role_assignments, :dependent => :destroy
   belongs_to :environment
   serialize :permissions, Array
@@ -1,33 +0,0 @@
-# inside solr
-solr/LICENSE.txt
-solr/NOTICE.txt
-solr/README.txt
-solr/etc/
-solr/work/
-solr/lib/
-solr/solr/README.txt
-solr/solr/solr.xml
-solr/start.jar
-solr/webapps/
-solr/solr/data/*
-
-Gemfile.lock
-test/solr
-test/tmp
-
-acts_as_solr_reloaded-*.gem
-*.log
-*.log
-*_pid
-
-coverage
-coverage/*
-coverage.data
-test/db/*.db
-test/log/*.log
-pkg/*
-*.sw?
-rdoc
-pkg
-tags
-.svn
@@ -1,13 +0,0 @@
-before_script:
-  - mongo mydb_test --eval 'db.addUser("travis", "test");'
-  - gem update --system 1.4.1 > /dev/null 2>&1
-  - rake solr:download
-  - RAILS_ENV=test rake solr:start
-
-script: "bundle exec rake $TASK --trace"
-
-rvm:
-  - 1.8.7
-env: 
-  - TASK=test
-  - TASK=test:functional
@@ -1,13 +0,0 @@
-source :rubygems
-
-gem 'ruby-debug'
-
-gem 'rails', '2.3.5'
-
-gem 'sqlite3'
-
-gem 'mongo_mapper', '0.7.6'
-gem 'bson_ext', '1.0'
-
-gem 'mocha'
-gem 'thoughtbot-shoulda'
@@ -1,22 +0,0 @@
-(The MIT License)
-
-Copyright © 2010
-
-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.
@@ -1,128 +0,0 @@
-[![Build status](https://secure.travis-ci.org/coletivoEITA/acts_as_solr_reloaded.png?branch=master)](http://travis-ci.org/coletivoEITA/acts_as_solr_reloaded)
-
-Description
-======
-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.
-
-This plugin is intended for use in old versions of Rails. For newer versions, I strongly advice using Sunspot!
-Nevertheless, this plugin is used for Noosfero project in production. Any problem please open an issue.
-
-It should support Rails 2.1 (and greater 2.x) and is developed latest Solr versions, so don't expect it to run on older Solr.
-
-Installation
-======
-
-Install as a plugin
-
-    script/plugin install git://github.com/brauliobo/acts_as_solr_reloaded.git
-
-Download Solr
-
-    rake solr:download
-
-Requirements
-------
-* Java Runtime Environment(JRE) 6.0 (or newer) from Oracle or OpenJDK
-
-Configuration
-======
-See config/solr.yml file.
-
-For solr configuration the important files are solrconfig.xml and schema.xml.
-
-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.search(query) #query is a string representing your query
-
-Please see ActsAsSolr::ActsMethods for a complete info
-
-Pagination
-======
-ActsAsSolr implements in SearchResults class an interface compatible with will_paginate and maybe others.
-
-In your tests
-======
-To test code that uses `acts_as_solr` you must start a Solr server for the test environment.
-You can add to the beggining of your test/test_helper.rb the code:
-
-    ENV["RAILS_ENV"] = "test"
-    abort unless system 'rake solr:start' 
-    at_exit { system 'rake solr:stop' }
-
-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
-
-Or to be more realistic and preserve performance, enable Solr when needed,
-by calling `TestSolr.enable` and disable solr otherwise by calling
-`TestSolr.disable` on `Test::Unit::TestCase`'s `setup`:
-
-     class ActsAsSolr::Post
-       class << self
-         alias_method :execute_orig, :execute
-       end
-     end
-     module ActsAsSolr::ParserMethods
-       alias_method :parse_results_orig, :parse_results
-     end
-     
-     class TestSolr
-     
-       def self.enable
-         ActsAsSolr::Post.class_eval do
-           def self.execute(*args)
-             execute_orig *args
-           end
-         end
-         ActsAsSolr::ParserMethods.module_eval do
-           def parse_results(*args)
-             parse_results_orig *args
-           end
-         end
-     
-         # clear index
-         ActsAsSolr::Post.execute(Solr::Request::Delete.new(:query => '*:*'))
-     
-         @solr_disabled = false
-       end
-     
-       def self.disable
-         return if @solr_disabled
-     
-         ActsAsSolr::Post.class_eval do
-           def self.execute(*args)
-             true
-           end
-         end
-         ActsAsSolr::ParserMethods.module_eval do
-           def parse_results(*args)
-             parse_results_orig nil, args[1]
-           end
-         end
-     
-         @solr_disabled = true
-       end
-     
-     end
-     
-     # disable solr actions by default
-     TestSolr.disable
-
-Release Information
-======
-Released under the MIT license.
@@ -1,71 +0,0 @@
-require 'rubygems'
-require 'rake'
-require 'rake/testtask'
-require 'rake/rdoctask'
-
-ENV['RAILS_ENV'] = "test"
-require File.expand_path("#{File.dirname(__FILE__)}/config/solr_environment")
-
-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
-    DB ||= 'sqlite'
-    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/**/*_shoulda.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 => :setup) 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
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |s|
-    s.name = "acts_as_solr_reloaded"
-    s.summary = "This gem adds full text search capabilities and many other nifty features from Apache Solr to any Rails model."
-    s.email = "dc.rec1@gmail.com"
-    s.homepage = "http://github.com/dcrec1/acts_as_solr_reloaded"
-    s.description = "This gem adds full text search capabilities and many other nifty features from Apache Solr to any Rails model."
-    s.authors = ["Diego Carrion"]
-    s.files =  FileList["[A-Z]*", "{bin,generators,config,lib,solr}/**/*"] +
-      FileList["test/**/*"].reject {|f| f.include?("test/log")}.reject {|f| f.include?("test/tmp")}
-  end
-rescue LoadError
-  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install jeweler"
-end
@@ -1,21 +0,0 @@
-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.
-
-== Install dependencies
-sudo apt-get install mongodb-server
-bundle install
-gem update --system 1.4.1
-
-== Running test
-To run the acts_as_solr's plugin tests run the following steps:
-
-- RAILS_ENV=test rake solr:start
-
-- rake test:unit
-(or just rake 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.
@@ -1 +0,0 @@
-1.6.0
 \ No newline at end of file
@@ -1,205 +0,0 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
-# -*- encoding: utf-8 -*-
-
-Gem::Specification.new do |s|
-  s.name = %q{acts_as_solr_reloaded}
-  s.version = "1.6.0"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Diego Carrion"]
-  s.date = %q{2011-03-20}
-  s.description = %q{This gem adds full text search capabilities and many other nifty features from Apache Solr to any Rails model.}
-  s.email = %q{dc.rec1@gmail.com}
-  s.extra_rdoc_files = [
-    "LICENSE",
-    "README.markdown",
-    "README.rdoc"
-  ]
-  s.files = [
-    "LICENSE",
-    "README.markdown",
-    "README.rdoc",
-    "Rakefile",
-    "TESTING_THE_PLUGIN",
-    "VERSION",
-    "config/solr.yml",
-    "config/solr_environment.rb",
-    "generators/dynamic_attributes_migration/dynamic_attributes_migration_generator.rb",
-    "generators/dynamic_attributes_migration/templates/migration.rb",
-    "generators/local_migration/local_migration_generator.rb",
-    "generators/local_migration/templates/migration.rb",
-    "lib/acts_as_solr.rb",
-    "lib/acts_as_solr/acts_methods.rb",
-    "lib/acts_as_solr/class_methods.rb",
-    "lib/acts_as_solr/common_methods.rb",
-    "lib/acts_as_solr/deprecation.rb",
-    "lib/acts_as_solr/dynamic_attribute.rb",
-    "lib/acts_as_solr/instance_methods.rb",
-    "lib/acts_as_solr/lazy_document.rb",
-    "lib/acts_as_solr/local.rb",
-    "lib/acts_as_solr/mongo_mapper.rb",
-    "lib/acts_as_solr/parser_methods.rb",
-    "lib/acts_as_solr/search_results.rb",
-    "lib/acts_as_solr/solr_fixtures.rb",
-    "lib/acts_as_solr/tasks.rb",
-    "lib/acts_as_solr_reloaded.rb",
-    "lib/solr.rb",
-    "lib/solr/connection.rb",
-    "lib/solr/document.rb",
-    "lib/solr/exception.rb",
-    "lib/solr/field.rb",
-    "lib/solr/importer.rb",
-    "lib/solr/importer/array_mapper.rb",
-    "lib/solr/importer/delimited_file_source.rb",
-    "lib/solr/importer/hpricot_mapper.rb",
-    "lib/solr/importer/mapper.rb",
-    "lib/solr/importer/solr_source.rb",
-    "lib/solr/importer/xpath_mapper.rb",
-    "lib/solr/indexer.rb",
-    "lib/solr/request.rb",
-    "lib/solr/request/add_document.rb",
-    "lib/solr/request/base.rb",
-    "lib/solr/request/commit.rb",
-    "lib/solr/request/delete.rb",
-    "lib/solr/request/dismax.rb",
-    "lib/solr/request/index_info.rb",
-    "lib/solr/request/modify_document.rb",
-    "lib/solr/request/optimize.rb",
-    "lib/solr/request/ping.rb",
-    "lib/solr/request/select.rb",
-    "lib/solr/request/spellcheck.rb",
-    "lib/solr/request/standard.rb",
-    "lib/solr/request/update.rb",
-    "lib/solr/response.rb",
-    "lib/solr/response/add_document.rb",
-    "lib/solr/response/base.rb",
-    "lib/solr/response/commit.rb",
-    "lib/solr/response/delete.rb",
-    "lib/solr/response/dismax.rb",
-    "lib/solr/response/index_info.rb",
-    "lib/solr/response/modify_document.rb",
-    "lib/solr/response/optimize.rb",
-    "lib/solr/response/ping.rb",
-    "lib/solr/response/ruby.rb",
-    "lib/solr/response/select.rb",
-    "lib/solr/response/spellcheck.rb",
-    "lib/solr/response/standard.rb",
-    "lib/solr/response/xml.rb",
-    "lib/solr/solrtasks.rb",
-    "lib/solr/util.rb",
-    "lib/solr/xml.rb",
-    "lib/tasks/database.rake",
-    "lib/tasks/solr.rake",
-    "lib/tasks/test.rake",
-    "test/config/solr.yml",
-    "test/db/connections/mysql/connection.rb",
-    "test/db/connections/sqlite/connection.rb",
-    "test/db/migrate/001_create_books.rb",
-    "test/db/migrate/002_create_movies.rb",
-    "test/db/migrate/003_create_categories.rb",
-    "test/db/migrate/004_create_electronics.rb",
-    "test/db/migrate/005_create_authors.rb",
-    "test/db/migrate/006_create_postings.rb",
-    "test/db/migrate/007_create_posts.rb",
-    "test/db/migrate/008_create_gadgets.rb",
-    "test/db/migrate/009_create_dynamic_attributes.rb",
-    "test/db/migrate/010_create_advertises.rb",
-    "test/db/migrate/011_create_locals.rb",
-    "test/db/test.db",
-    "test/fixtures/advertises.yml",
-    "test/fixtures/authors.yml",
-    "test/fixtures/books.yml",
-    "test/fixtures/categories.yml",
-    "test/fixtures/db_definitions/mysql.sql",
-    "test/fixtures/dynamic_attributes.yml",
-    "test/fixtures/electronics.yml",
-    "test/fixtures/locals.yml",
-    "test/fixtures/movies.yml",
-    "test/fixtures/postings.yml",
-    "test/functional/acts_as_solr_test.rb",
-    "test/functional/association_indexing_test.rb",
-    "test/functional/faceted_search_test.rb",
-    "test/functional/multi_solr_search_test.rb",
-    "test/models/advertise.rb",
-    "test/models/author.rb",
-    "test/models/book.rb",
-    "test/models/category.rb",
-    "test/models/document.rb",
-    "test/models/dynamic_attribute.rb",
-    "test/models/electronic.rb",
-    "test/models/gadget.rb",
-    "test/models/local.rb",
-    "test/models/movie.rb",
-    "test/models/novel.rb",
-    "test/models/post.rb",
-    "test/models/posting.rb",
-    "test/test_helper.rb",
-    "test/unit/acts_methods_shoulda.rb",
-    "test/unit/class_methods_shoulda.rb",
-    "test/unit/common_methods_shoulda.rb",
-    "test/unit/instance_methods_shoulda.rb",
-    "test/unit/lazy_document_shoulda.rb",
-    "test/unit/parser_instance.rb",
-    "test/unit/parser_methods_shoulda.rb",
-    "test/unit/solr_instance.rb",
-    "test/unit/test_helper.rb"
-  ]
-  s.homepage = %q{http://github.com/dcrec1/acts_as_solr_reloaded}
-  s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.5.0}
-  s.summary = %q{This gem adds full text search capabilities and many other nifty features from Apache Solr to any Rails model.}
-  s.test_files = [
-    "test/db/connections/mysql/connection.rb",
-    "test/db/connections/sqlite/connection.rb",
-    "test/db/migrate/001_create_books.rb",
-    "test/db/migrate/002_create_movies.rb",
-    "test/db/migrate/003_create_categories.rb",
-    "test/db/migrate/004_create_electronics.rb",
-    "test/db/migrate/005_create_authors.rb",
-    "test/db/migrate/006_create_postings.rb",
-    "test/db/migrate/007_create_posts.rb",
-    "test/db/migrate/008_create_gadgets.rb",
-    "test/db/migrate/009_create_dynamic_attributes.rb",
-    "test/db/migrate/010_create_advertises.rb",
-    "test/db/migrate/011_create_locals.rb",
-    "test/functional/acts_as_solr_test.rb",
-    "test/functional/association_indexing_test.rb",
-    "test/functional/faceted_search_test.rb",
-    "test/functional/multi_solr_search_test.rb",
-    "test/models/advertise.rb",
-    "test/models/author.rb",
-    "test/models/book.rb",
-    "test/models/category.rb",
-    "test/models/document.rb",
-    "test/models/dynamic_attribute.rb",
-    "test/models/electronic.rb",
-    "test/models/gadget.rb",
-    "test/models/local.rb",
-    "test/models/movie.rb",
-    "test/models/novel.rb",
-    "test/models/post.rb",
-    "test/models/posting.rb",
-    "test/test_helper.rb",
-    "test/unit/acts_methods_shoulda.rb",
-    "test/unit/class_methods_shoulda.rb",
-    "test/unit/common_methods_shoulda.rb",
-    "test/unit/instance_methods_shoulda.rb",
-    "test/unit/lazy_document_shoulda.rb",
-    "test/unit/parser_instance.rb",
-    "test/unit/parser_methods_shoulda.rb",
-    "test/unit/solr_instance.rb",
-    "test/unit/test_helper.rb"
-  ]
-
-  if s.respond_to? :specification_version then
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-    else
-    end
-  else
-  end
-end
-
@@ -1,22 +0,0 @@
-# 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://0.0.0.0:8982/solr
-  jvm_options: -server -Xmx128M -Xms16M
-  timeout: 0
-
-production:
-  url: http://127.0.0.1:8983/solr
-  jvm_options: -server -Xmx192M -Xms64M
-  timeout: 0
-
-test: &TEST
-  url: http://0.0.0.0:8981/solr
-  jvm_options: -server -Xmx128M -Xms16M
-  timeout: 0
-
-cucumber:
-  <<: *TEST
@@ -1,49 +0,0 @@
-ENV['RAILS_ENV'] = (ENV['RAILS_ENV'] || 'development').dup
-require "uri"
-require "fileutils"
-require "yaml"
-require 'net/http'
-
-dir = File.dirname(__FILE__)
-SOLR_PATH = File.expand_path("#{dir}/../solr") unless defined? SOLR_PATH
-
-unless defined? Rails.root
-  # define Rails.root for test environment
-  Rails.root = defined?(Rails) ? Rails.root : File.expand_path("#{File.dirname(__FILE__)}/../test")
-end
-unless defined? RAILS_ENV
-  RAILS_ENV = ENV['RAILS_ENV']
-end
-unless defined? SOLR_LOGS_PATH
-  SOLR_LOGS_PATH = ENV["SOLR_LOGS_PATH"] || "#{Rails.root}/log"
-end
-unless defined? SOLR_PIDS_PATH
-  SOLR_PIDS_PATH = ENV["SOLR_PIDS_PATH"] || "#{Rails.root}/tmp/pids"
-end
-unless defined? SOLR_DATA_PATH
-  SOLR_DATA_PATH = ENV["SOLR_DATA_PATH"] || "#{Rails.root}/solr/#{ENV['RAILS_ENV']}"
-end
-unless defined? SOLR_CONFIG_PATH
-  SOLR_CONFIG_PATH = ENV["SOLR_CONFIG_PATH"] || "#{SOLR_PATH}/solr"
-end
-unless defined? SOLR_PID_FILE
-  SOLR_PID_FILE="#{SOLR_PIDS_PATH}/solr.#{ENV['RAILS_ENV']}.pid"
-end
-
-unless defined? SOLR_PORT
-  config = YAML::load_file(Rails.root+'/config/solr.yml')
-  raise("No solr environment defined for RAILS_ENV = #{ENV['RAILS_ENV'].inspect}") unless config[ENV['RAILS_ENV']]
-
-  SOLR_HOST = ENV['HOST'] || URI.parse(config[ENV['RAILS_ENV']]['url']).host
-  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'
-  require "active_record"
-  DB = (ENV['DB'] ? ENV['DB'] : 'sqlite') 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
-
@@ -1,7 +0,0 @@
-class DynamicAttributesMigrationGenerator < Rails::Generator::Base 
-  def manifest 
-    record do |m| 
-      m.migration_template 'migration.rb', 'db/migrate', :migration_file_name => "dynamic_attributes_migration"
-    end
-  end
-end
 \ No newline at end of file
@@ -1,17 +0,0 @@
-class DynamicAttributesMigration < ActiveRecord::Migration
-  def self.up
-    create_table :dynamic_attributes do |t|
-      t.integer :dynamicable_id
-      t.string  :dynamicable_type
-      t.string :name
-      t.text :value
-      t.timestamps
-    end
-    add_index :dynamic_attributes, [:dynamicable_id, :dynamicable_type, :name], :unique => true,  :name => 'da_pk'
-  end
-
-  def self.down
-    remove_index 'da_pk'
-    drop_table :dynamic_attributes
-  end
-end
@@ -1,7 +0,0 @@
-class LocalMigrationGenerator < Rails::Generator::Base 
-  def manifest 
-    record do |m| 
-      m.migration_template 'migration.rb', 'db/migrate', :migration_file_name => "local_migration"
-    end
-  end
-end
 \ No newline at end of file
@@ -1,16 +0,0 @@
-class LocalMigration < ActiveRecord::Migration
-  def self.up
-    create_table :locals do |t|
-      t.integer :localizable_id
-      t.string  :localizable_type
-      t.string :latitude
-      t.string :longitude
-
-      t.timestamps
-    end
-  end
-  
-  def self.down
-    drop_table :locals
-  end
-end
 \ No newline at end of file
@@ -1 +0,0 @@
-require 'acts_as_solr'
 \ No newline at end of file
@@ -1,5 +0,0 @@
-require 'fileutils'
-
-src = File.join(File.dirname(__FILE__), 'config', 'solr.yml')
-target = File.join(File.dirname(__FILE__), '..', '..', '..', 'config', 'solr.yml')
-FileUtils.cp src, target
 \ No newline at end of file
@@ -1,25 +0,0 @@
-require 'active_record'
-require 'rexml/document'
-require 'net/http'
-require 'yaml'
-require 'time'
-require 'erb'
-require 'rexml/xpath'
-
-require File.dirname(__FILE__) + '/solr'
-require File.dirname(__FILE__) + '/acts_as_solr/acts_methods'
-require File.dirname(__FILE__) + '/acts_as_solr/common_methods'
-require File.dirname(__FILE__) + '/acts_as_solr/parser_methods'
-require File.dirname(__FILE__) + '/acts_as_solr/class_methods'
-require File.dirname(__FILE__) + '/acts_as_solr/dynamic_attribute'
-require File.dirname(__FILE__) + '/acts_as_solr/local'
-require File.dirname(__FILE__) + '/acts_as_solr/instance_methods'
-require File.dirname(__FILE__) + '/acts_as_solr/common_methods'
-require File.dirname(__FILE__) + '/acts_as_solr/deprecation'
-require File.dirname(__FILE__) + '/acts_as_solr/search_results'
-require File.dirname(__FILE__) + '/acts_as_solr/lazy_document'
-require File.dirname(__FILE__) + '/acts_as_solr/mongo_mapper'
-require File.dirname(__FILE__) + '/acts_as_solr/post'
-
-# reopen ActiveRecord and include the acts_as_solr method
-ActiveRecord::Base.extend ActsAsSolr::ActsMethods
@@ -1,390 +0,0 @@
-# a list of models which called acts_as_solr
-$solr_indexed_models = []
-
-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
-    #
-    # dynamic_attributes: Default false. When true, requires a has_many relationship to a DynamicAttribute
-    #                     (:name, :value) model. Then, all dynamic attributes will be mapped as normal attributes
-    #                    in Solr, so you can filter like this: Model.find_by_solr "#{dynamic_attribute.name}:Lorem"
-    #
-    # taggable: Default false. When true, indexes tags with field name tag. Tags are taken from taggings.tag
-    #
-    # spatial: Default false. When true, indexes model.local.latitude and model.local.longitude as coordinates.
-    # 
-    def acts_as_solr(options={}, solr_options={}, &deferred_solr_configuration)
-
-      $solr_indexed_models << self
-
-      extend ClassMethods
-      include InstanceMethods
-      include CommonMethods
-      include ParserMethods
-
-      define_solr_configuration_methods
-
-      acts_as_taggable_on :tags if options[:taggable]
-      has_many :dynamic_attributes, :as => "dynamicable" if options[:dynamic_attributes]
-      has_one :local, :as => "localizable" if options[:spatial]
-
-      after_save    :solr_save
-      after_destroy :solr_destroy
-
-      if deferred_solr_configuration
-        self.deferred_solr_configuration = deferred_solr_configuration
-      else
-        process_acts_as_solr(options, solr_options)
-      end
-    end
-
-    def process_acts_as_solr(options, solr_options)
-      process_solr_options(options, solr_options)
-    end
-
-    def define_solr_configuration_methods
-      # I'd like to use cattr_accessor, but it does not support lazy loaders and delegation to the class in the instance methods.
-      # TODO: Reconcile with cattr_accessor, or a more appropriate method.
-      class_eval(<<-EOS, __FILE__, __LINE__)
-      @@configuration = nil unless defined?(@@configuration)
-      @@solr_configuration = nil unless defined?(@@solr_configuration)
-      @@deferred_solr_configuration = nil unless defined?(@@deferred_solr_configuration)
-
-      def self.configuration
-        return @@configuration if @@configuration
-        process_deferred_solr_configuration
-        @@configuration
-      end
-      def configuration
-        self.class.configuration
-      end
-      def self.configuration=(value)
-        @@configuration = value
-      end
-      def configuration=(value)
-        self.class.configuration = value
-      end
-
-      def self.solr_configuration
-        return @@solr_configuration if @@solr_configuration
-        process_deferred_solr_configuration
-        @@solr_configuration
-      end
-      def solr_configuration
-        self.class.solr_configuration
-      end
-      def self.solr_configuration=(value)
-        @@solr_configuration = value
-      end
-      def solr_configuration=(value)
-        self.class.solr_configuration = value
-      end
-
-      def self.deferred_solr_configuration
-        return @@deferred_solr_configuration if @@deferred_solr_configuration
-        @@deferred_solr_configuration
-      end
-      def deferred_solr_configuration
-        self.class.deferred_solr_configuration
-      end
-      def self.deferred_solr_configuration=(value)
-        @@deferred_solr_configuration = value
-      end
-      def deferred_solr_configuration=(value)
-        self.class.deferred_solr_configuration = value
-      end
-      EOS
-    end
-
-    def process_deferred_solr_configuration
-      return unless deferred_solr_configuration
-      options, solr_options = deferred_solr_configuration.call
-      self.deferred_solr_configuration = nil
-      self.process_solr_options(options, solr_options)
-    end
-
-    def process_solr_options(options={}, solr_options={})
-      self.configuration = {
-        :fields => nil,
-        :format => :objects,
-        :additional_fields => nil,
-        :dynamic_attributes => false,
-        :exclude_fields => [],
-        :auto_commit => ['production'].include?(Rails.env) ? false : true,
-        :include => nil,
-        :facets => nil,
-        :boost => nil,
-        :if => "true",
-        :offline => false,
-        :spatial => false,
-      }
-      self.solr_configuration = {
-        :type_field => "type_s",
-        :primary_key_field => "pk_s",
-        :default_boost => 1.0,
-      }
-
-      solr_options ||= {}
-      raise "Invalid options: #{(options.keys-configuration.keys).join(',')}" unless (options.keys-configuration.keys).empty?
-      raise "Invalid solr options: #{(solr_options.keys-solr_configuration.keys).join(',')}" unless (solr_options.keys-solr_configuration.keys).empty?
-
-      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] = {}
-
-      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
-
-      process_includes(configuration[:include]) if configuration[:include]
-    end
-
-    def after_save_reindex(associations, options = {})
-      extend ActsAsSolr::CommonMethods
-      Array(associations).each do |association|
-        after_save do |ar|
-          if options[:with] == :delayed_job
-            delay(:run_at => (Date.today+1.day).to_time+4.hours).solr_batch_add_association ar, association
-          else
-            solr_batch_add_association ar, association
-          end
-        end
-      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" do
-        value = self.send field_name
-        case options[:type]
-        when :date # format dates properly; return nil for nil dates
-          value ? (value.respond_to?(:utc) ? value.utc : value).strftime("%Y-%m-%dT%H:%M:%SZ") : nil
-        else
-          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)
-      Array(includes).each do |assoc|
-        field_name, options = determine_field_name_and_options(assoc)
-        configuration[:solr_includes][field_name] = options
-      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]
-        column_type = format_column_type(column.type)
-        
-        case column_type
-          when :string then :string
-          when :datetime then :date
-          when :time then :date
-          else column_type
-        end
-      else
-        :text
-      end
-    end
-    
-    def format_column_type(type)
-      if type.class.eql? Symbol
-        type
-      else
-        type.to_s.eql?("ObjectId") ? :string : type.to_s.downcase.to_sym
-      end
-    end
-  end
-end
-
@@ -1,278 +0,0 @@
-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
-    # 
-    # For specific fields searching use :filter_queries options
-    # 
-    # ====options:
-    # offset:: - The first document to be retrieved (offset)
-    # page:: - The page to be retrieved
-    # limit:: - The number of rows per page
-    # per_page:: - Alias for limit
-    # filter_queries:: - Use solr filter queries to sort by fields
-    #
-    #             Book.find_by_solr 'ruby', :filter_queries => ['price:5']
-    #
-    # sort:: - Orders (sort by) the result set using a given criteria:
-    #
-    #             Book.find_by_solr 'ruby', :sort => '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.
-    #
-    # relevance:: Sets fields relevance
-    #
-    #            Book.find_by_solr "zidane", :relevance => {:title => 5, :author => 2}
-    #
-    def find_by_solr(query, options={})
-      data = parse_query(query, options)
-      return parse_results(data, options)
-    end
-    alias :search :find_by_solr
-    
-    # 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})
-    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 = {})
-      options.update(:results_format => :objects) unless options[:results_format]
-      data = parse_query(query, options)
-      
-      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["id"].to_s}}
-      end
-      result
-    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=300, options = {}, &finder)
-      finder ||= lambda do |ar, sql_options|
-        ar.all sql_options.merge!({:order => self.primary_key, :include => configuration[:solr_includes].keys})
-      end
-      start_time = Time.now
-      options[:offset] ||= 0
-      options[:threads] ||= 2
-      options[:delayed_job] &= defined?(Delayed::Job)
-
-      if batch_size > 0
-        items_processed = 0
-        offset = options[:offset]
-        end_reached = false
-        threads = []
-        mutex = Mutex.new
-        queue = Queue.new
-        loop do
-          items = finder.call(self, {:limit => batch_size, :offset => offset})
-          add_batch = items.collect { |content| content.to_solr_doc }
-          offset += items.size
-          end_reached = items.size == 0
-          break if end_reached
-
-          if options[:threads] == threads.size
-            threads.first.join 
-            threads.shift
-          end
-
-          queue << [items, add_batch]
-          threads << Thread.new do
-            iteration_start = Time.now
-
-            iteration_items, iteration_add_batch = queue.pop(true)
-            if options[:delayed_job]
-              delay.solr_add iteration_add_batch
-            else
-              solr_add iteration_add_batch
-              solr_commit
-            end
-
-            last_id = iteration_items.last.id
-            time_so_far = Time.now - start_time
-            iteration_time = Time.now - iteration_start         
-            mutex.synchronize do
-              items_processed += iteration_items.size
-              if options[:delayed_job]
-                logger.info "#{Process.pid}: #{items_processed} items for #{self.name} have been sent to Delayed::Job in #{'%.3f' % time_so_far}s at #{'%.3f' % (items_processed / time_so_far)} items/sec. Last id: #{last_id}"
-              else
-                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. Last id: #{last_id}"
-              end
-            end
-          end
-        end
-
-        solr_commit if options[:delayed_job]
-        threads.each{ |t| t.join }
-      else
-        items = finder.call(self, {})
-        items.each { |content| content.solr_save }
-        items_processed = items.size
-      end
-
-      if items_processed > 0
-        solr_optimize
-        time_elapsed = Time.now - start_time
-        logger.info "Index for #{self.name} has been rebuilt (took #{'%.3f' % time_elapsed}s)"
-      else
-        "Nothing to index for #{self.name}"
-      end
-    end
-
-    alias :rebuild_index :rebuild_solr_index
-  end
-end
@@ -1,77 +0,0 @@
-module ActsAsSolr #:nodoc:
-  
-  module CommonMethods
-
-    TypeMapping = {
-      :double => "do",
-      :float => "f",
-      :decimal => "f",
-      :integer => "i",
-      :boolean => "b",
-      :string => "s",
-      :date => "d",
-      :range_float => "rf",
-      :range_integer => "ri",
-      :facet => "facet",
-      :text => "t",
-    }
-
-    # Converts field types into Solr types
-    def get_solr_field_type(field_type)
-      if field_type.is_a?(Symbol)
-        t = TypeMapping[field_type]
-        raise "Unknown field_type symbol: #{field_type}" if t.nil?
-        t
-      elsif field_type.is_a?(String)
-        return field_type
-      else
-        raise "Unknown field_type class: #{field_type.class}: #{field_type}"
-      end
-    end
-
-    def solr_batch_add(objects)
-      solr_add objects.map{ |a| a.to_solr_doc }
-      solr_commit if defined?(configuration) and configuration[:auto_commit]
-    end
-
-    def solr_batch_add_association(ar, association)
-      result = ar.send(association)
-      result = [result] unless result.is_a?(Array)
-      solr_batch_add result
-    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
@@ -1,61 +0,0 @@
-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 :sort instead!"
-        options[:sort] ||= 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
@@ -1,3 +0,0 @@
-class DynamicAttribute < ActiveRecord::Base
-  belongs_to :dynamicable, :polymorphic => true
-end
@@ -1,194 +0,0 @@
-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) 
-        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?
-      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
-      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|
-        next if [self.class.primary_key, "type"].include?(field_name.to_s)
-
-        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") rescue nil
-        next if value.nil?
-
-        suffix = get_solr_field_type(field_type)
-        value = Array(value).map{ |v| ERB::Util.html_escape(v) } # escape each value
-        value = value.first if value.size == 1
-
-        field = Solr::Field.new(:name => "#{solr_name}_#{suffix}", :value => value)
-        processed_boost = validate_boost(field_boost)
-        field.boost = processed_boost
-        doc << field
-      end
-      
-      add_dynamic_attributes(doc)
-      add_includes(doc)
-      add_tags(doc)
-      add_space(doc)
-      
-      debug doc.to_json
-      doc
-    end
-
-    private
-    
-    def debug(text)
-      logger.debug text rescue nil
-    end
-
-    def add_space(doc)
-      if configuration[:spatial] and local
-        doc << Solr::Field.new(:name => "lat_f", :value => local.latitude)
-        doc << Solr::Field.new(:name => "lng_f", :value => local.longitude)
-      end
-    end
-    
-    def add_tags(doc)
-      taggings.each do |tagging|
-        doc << Solr::Field.new(:name => "tag_facet", :value => tagging.tag.name)
-        doc << Solr::Field.new(:name => "tag_t", :value => tagging.tag.name)
-      end if configuration[:taggable]
-    end
-    
-    def add_dynamic_attributes(doc)
-      dynamic_attributes.each do |attribute|
-        value = ERB::Util.html_escape(attribute.value)
-        doc << Solr::Field.new(:name => "#{attribute.name.downcase}_t", :value => value)
-        doc << Solr::Field.new(:name => "#{attribute.name.downcase}_facet", :value => value)
-      end if configuration[:dynamic_attributes]
-    end
-
-    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).compact
-            unless records.empty?
-              records.each {|r| data << include_value(r, options)}
-              Array(data).each do |value|
-                field = Solr::Field.new(:name => "#{field_name}_#{suffix}", :value => value)
-                processed_boost = validate_boost(field_boost)
-                field.boost = processed_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
-        if options[:fields]
-          fields = {}
-          options[:fields].each{ |f| fields[f] = record.send(f) }
-        else
-          fields = record.attributes
-        end
-        fields.map{ |k,v| ERB::Util.html_escape(v) }.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
@@ -1,18 +0,0 @@
-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
@@ -1,4 +0,0 @@
-class Local < ActiveRecord::Base
-  belongs_to :localizable, :polymorphic => true
-  validates_presence_of :latitude, :longitude
-end
 \ No newline at end of file
@@ -1,24 +0,0 @@
-module ActsAsSolr
-  module MongoMapper
-    def self.included(clazz)
-      clazz.extend ActsAsSolr::ActsMethods
-      clazz.extend ClassMethods
-    end
-    
-    module ClassMethods
-      def columns_hash
-        keys
-      end
-      
-      def primary_key
-        'id'
-      end
-
-      def merge_conditions(*args)
-        ret = {}
-        args.each{ |a| ret.merge!(a) if a.is_a?(Hash) }
-        ret
-      end
-    end
-  end
-end
@@ -1,273 +0,0 @@
-module ActsAsSolr #:nodoc:
-  module ParserMethods
-    protected
-
-    # Method used by mostly all the ClassMethods when doing a search
-    def parse_query(query=nil, options={})
-      valid_options = [:models, :lazy, :core, :results_format, :sql_options,
-        :alternate_query, :boost_functions, :filter_queries, :facets, :sort,
-        :scores, :operator, :latitude, :longitude, :radius, :relevance, :highlight,
-        :offset, :per_page, :limit, :page,]
-      query_options = {}
-
-      return if query.nil?
-      raise "Query should be a string" unless query.is_a?(String)
-      raise "Invalid parameters: #{(options.keys - valid_options).join(',')}" unless (options.keys - valid_options).empty?
-      begin
-        Deprecation.validate_query(options)
-
-        query_options[:filter_queries] = []
-        query.strip!
-
-        # using *:* disable index boosts, so use the type filter
-        if query.blank?
-          query = solr_type_condition(options)
-        else
-          query = sanitize_query(query)
-          query_options[:filter_queries] << solr_type_condition(options)
-
-          # put types on filtered fields
-          query = replace_types([*query], ':').first
-        end
-
-        query_options[:filter_queries] += replace_types([*options[:filter_queries]], ':') if options[:filter_queries]
-
-        options[:alternate_query] ||= ''
-        options[:alternate_query].strip!
-        query = "#{options[:alternate_query]} #{query}" unless options[:alternate_query].blank?
-
-        query = add_relevance query, options[:relevance]
-
-        query_options[:query] = query
-
-        field_list = options[:models].nil? ? solr_configuration[:primary_key_field] : "id"
-        query_options[:field_list] = [field_list, 'score']
-
-        per_page = options[:per_page] || options[:limit] || 30
-        offset = options[:offset] || (((options[:page] || 1).to_i - 1) * per_page)
-        query_options[:rows] = per_page
-        query_options[:start] = offset
-
-        query_options[:operator] = options[:operator]
-
-        query_options[:boost_functions] = replace_types([*options[:boost_functions]], '').join(' ') if options[:boost_functions]
-
-        # 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].map{ |k| "#{k}_facet" } if options[:facets][:fields]
-          query_options[:filter_queries] += replace_types([*options[:facets][:browse]]) if options[:facets][:browse]
-          query_options[:facets][:queries] = replace_types([*options[:facets][:query]]) 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.dup.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 options[:highlight]
-          query_options[:highlighting] = {}
-          query_options[:highlighting][:field_list] = replace_types([*options[:highlight][:fields]], '') if options[:highlight][:fields]
-          query_options[:highlighting][:require_field_match] =  options[:highlight][:require_field_match] if options[:highlight][:require_field_match]
-          query_options[:highlighting][:max_snippets] = options[:highlight][:max_snippets] if options[:highlight][:max_snippets]
-          query_options[:highlighting][:prefix] = options[:highlight][:prefix] if options[:highlight][:prefix]
-          query_options[:highlighting][:suffix] = options[:highlight][:suffix] if options[:highlight][:suffix]
-        end
-
-        query_options[:sort] = replace_types([*options[:sort]], '')[0] if options[:sort]
-
-        if options[:radius]
-          query_options[:radius] = options[:radius]
-          query_options[:filter_queries] << '{!geofilt}'
-        end
-        query_options[:latitude] = options[:latitude]
-        query_options[:longitude] = options[:longitude]
-
-        not_dismax = query_options[:operator] == :or
-        request = not_dismax ? Solr::Request::Standard.new(query_options) : Solr::Request::Dismax.new(query_options)
-        ActsAsSolr::Post.execute(request, options[:core])
-      rescue
-        raise "#{$query} There was a problem executing your search\n#{query_options.inspect}\n: #{$!} in #{$!.backtrace.first}"
-      end
-    end
-
-    def solr_type_condition(options = {})
-      classes = [self] + (self.subclasses || []) + (options[:models] || [])
-      classes.map do |klass|
-        next if klass.name.empty?
-        "#{solr_configuration[:type_field]}:\"#{klass.name}\""
-      end.compact.join(' OR ')
-    end
-
-    # Parses the data returned from Solr
-    def parse_results(solr_data, options = {})
-      results = {
-        :docs => [],
-        :total => 0
-      }
-
-      configuration = {
-        :format => :objects
-      }
-      results.update(:spellcheck => solr_data.data['spellcheck']) unless solr_data.nil?
-      results.update(:facets => {'facet_fields' => []}) if options[:facets]
-      unless solr_data.nil? or solr_data.header['params'].nil?
-        header = solr_data.header
-        results.update :rows => header['params']['rows']
-        results.update :start => header['params']['start']
-      end
-      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]
-
-      highlighted = {}
-      solr_data.highlighting.map do |x,y|
-        e={}
-        y1=y.map{|x1,y1| e[x1.gsub(/_[^_]*/,"")]=y1} unless y.nil?
-        highlighted[x.gsub(/[^:]*:/,"").to_i]=e
-        end unless solr_data.highlighting.nil?
-
-      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']})
-      results.update({:highlights=>highlighted})
-      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
-        find_options = options[:sql_options] || {}
-        find_options[:conditions] = self.send :merge_conditions, {self.primary_key => ids}, (find_options[:conditions] || [])
-        result = self.all(find_options) || []
-        result = reorder(result, ids) unless find_options[:order]
-        result
-      else
-        ids
-      end
-
-      result
-    end
-
-    # Reorders the instances keeping the order returned from Solr
-    def reorder(things, ids)
-      ordered_things = []
-      ids.each do |id|
-        thing = things.find{ |t| t.id.to_s == id.to_s }
-        ordered_things |= [thing] if 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, suffix=':')
-      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(/\b#{solr_name}\b#{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(/\b#{solr_name}\b#{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
-
-    def sanitize_query(query)
-      fields = self.configuration[:solr_fields].keys
-      fields += DynamicAttribute.all(:select => 'name', :group => 'name').map(&:name) if DynamicAttribute.table_exists?
-      Solr::Util::query_parser_escape query, fields
-    end
-
-    private
-
-    def add_relevance(query, relevance)
-      return query if relevance.nil? or query.include? ':'
-
-      query = [query] + relevance.map do |attribute, value|
-        "#{attribute}:(#{query})^#{value}"
-      end
-      query = query.join(' OR ')
-
-      replace_types([query], '').first
-    end
-
-  end
-end
-
@@ -1,29 +0,0 @@
-module ActsAsSolr
-  class Post
-    class << self
-      def config
-        return @config if @config
-        @config = {}
-        YAML::load_file("#{Rails.root}/config/solr.yml")[Rails.env].each{ |k,v| @config[k.to_sym] = v }
-        @config
-      end
-
-      def options
-        @options ||= credentials.merge config
-      end
-
-      def credentials
-        @credentials ||= {:username => config[:username], :password => config[:password]}
-      end
-
-      def url(core)
-        core.nil? ? config[:url] : "#{config[:url]}/#{core}"
-      end
-
-      def execute(request, core = nil)
-        connection = Solr::Connection.new(url(core), options)
-        connection.send request
-      end
-    end
-  end
-end
@@ -1,136 +0,0 @@
-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
-
-    include Enumerable
-
-    def initialize(solr_data={})
-      @solr_data = solr_data
-    end
-
-    def each(&block)
-      self.results.each &block
-    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
-
-    # Returns the highlighted fields which one has asked for..
-    def highlights
-      @solr_data[:highlights]
-    end
-    
-    # Returns a suggested query
-    def suggest
-      Hash[@solr_data[:spellcheck]['suggestions']]['collation']
-    end
-
-    # Returns the number of documents per page
-    def per_page
-      @solr_data[:rows].to_i
-    end
-
-    # Returns the number of pages found
-    def total_pages
-      per_page.zero? ? 0 : (total / per_page.to_f).ceil
-    end
-
-    # Returns the current page
-    def current_page
-      per_page.zero? ? 0 : (@solr_data[:start].to_i / per_page) + 1
-    end
-
-    def blank?
-      total_entries == 0
-    end
-
-    def size
-      total_entries
-    end
-
-    def offset
-      (current_page - 1) * per_page
-    end
-
-    def previous_page
-      if current_page > 1
-        current_page - 1
-      else
-        false
-      end
-    end
-
-    def next_page
-      if current_page < total_pages
-        current_page + 1
-      else
-        false
-      end
-    end
-
-    def method_missing(symbol, *args, &block)
-      self.results.send(symbol, *args, &block)
-    rescue NoMethodError
-      raise NoMethodError, "There is no method called #{symbol} at #{self.class.name} - #{self.inspect}"
-    end
-
-    alias docs results
-    alias records results
-    alias num_found total
-    alias total_hits total
-    alias total_entries total
-    alias highest_score max_score
-  end
-
-end
-
@@ -1,13 +0,0 @@
-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
@@ -1,10 +0,0 @@
-dir = File.dirname(__FILE__)
-require 'rubygems'
-require 'rake'
-require 'net/http'
-require 'active_record'
-require File.expand_path("#{dir}/solr_fixtures")
-
-load File.expand_path("#{dir}/tasks/database.rake")
-load File.expand_path("#{dir}/tasks/solr.rake")
-load File.expand_path("#{dir}/tasks/test.rake")
@@ -1 +0,0 @@
-require 'acts_as_solr'
 \ No newline at end of file
@@ -1,27 +0,0 @@
-# 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 File.expand_path("#{File.dirname(__FILE__)}/solr/exception")
-require File.expand_path("#{File.dirname(__FILE__)}/solr/request")
-require File.expand_path("#{File.dirname(__FILE__)}/solr/connection")
-require File.expand_path("#{File.dirname(__FILE__)}/solr/response")
-require File.expand_path("#{File.dirname(__FILE__)}/solr/util")
-require File.expand_path("#{File.dirname(__FILE__)}/solr/xml")
-require File.expand_path("#{File.dirname(__FILE__)}/solr/importer")
-require File.expand_path("#{File.dirname(__FILE__)}/solr/indexer")
-require File.expand_path("#{File.dirname(__FILE__)}/solr/xml")
-require File.expand_path("#{File.dirname(__FILE__)}/solr/field")
-require File.expand_path("#{File.dirname(__FILE__)}/solr/request/base")
-require File.expand_path("#{File.dirname(__FILE__)}/solr/document")
-require File.expand_path("#{File.dirname(__FILE__)}/solr/request/json_update")
-require File.expand_path("#{File.dirname(__FILE__)}/solr/request/update")
@@ -1,180 +0,0 @@
-# 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: 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].to_i || 0
-    @username = opts[:username] if opts[:username]
-    @password = opts[:password] if opts[:password]
-  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)
-    req = Net::HTTP::Post.new(@url.path + "/" + request.handler,
-      { "Content-Type" => request.content_type })
-    req.basic_auth(@username, @password) if @username && @password
-    response = @connection.request(req, request.to_s)
-  
-    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
@@ -1,85 +0,0 @@
-# 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::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(:name => :creator, :value => 'Jorge Luis Borges')
-  def initialize(hash={})
-    @fields = []
-    self << hash
-  end
-
-  # Append a Solr::Field
-  #
-  #   doc << Solr::Field.new(:name => :creator, :value => 'Jorge Luis Borges')
-  #
-  # If you are truly lazy you can simply pass in a hash:
-  #
-  #   doc << {:name => :creator, :value => '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 => name, :value => v)}
-        else
-          @fields << Solr::Field.new(:name => name, :value => 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 => name, :value => value)
-  end
-
-  def to_jsonhash
-    hash = {'doc' => {}}
-    hash['boost'] = @boost if @boost
-    @fields.each{ |f| hash['doc'][f.name] = f.value_to_jsonhash }
-    hash
-  end
-
-  def to_json
-    to_jsonhash.to_json
-  end
-
-  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
@@ -1,13 +0,0 @@
-# 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
@@ -1,44 +0,0 @@
-# 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::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 = params[:name].to_s
-    @value = params[:value]
-    # Convert any Time values into UTC/XML schema format (which Solr requires).
-    @value = @value.respond_to?(:utc) ? @value.utc.xmlschema : @value
-  end
-
-  def value_to_jsonhash
-    @boost.nil? ? @value : {'boost' => @boost, 'value' => @value}
-  end 
-
-  def boost=(value)
-    @boost = value == 1.0 ? nil : value
-  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.to_str
-    return e
-  end
-
-end
@@ -1,19 +0,0 @@
-# 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 File.expand_path("#{File.dirname(__FILE__)}/importer/mapper")
-require File.expand_path("#{File.dirname(__FILE__)}/importer/array_mapper")
-require File.expand_path("#{File.dirname(__FILE__)}/importer/delimited_file_source")
-require File.expand_path("#{File.dirname(__FILE__)}/importer/hpricot_mapper")
-require File.expand_path("#{File.dirname(__FILE__)}/importer/xpath_mapper")
-require File.expand_path("#{File.dirname(__FILE__)}/importer/solr_source")
 \ No newline at end of file
@@ -1,26 +0,0 @@
-# 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
@@ -1,38 +0,0 @@
-# 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
@@ -1,27 +0,0 @@
-# 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
@@ -1,51 +0,0 @@
-# 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
@@ -1,41 +0,0 @@
-# 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::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
@@ -1,35 +0,0 @@
-# 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
@@ -1,52 +0,0 @@
-# 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
@@ -1,26 +0,0 @@
-# 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 File.expand_path("#{File.dirname(__FILE__)}/request/base")
-require File.expand_path("#{File.dirname(__FILE__)}/request/update")
-require File.expand_path("#{File.dirname(__FILE__)}/request/add_document")
-require File.expand_path("#{File.dirname(__FILE__)}/request/modify_document")
-require File.expand_path("#{File.dirname(__FILE__)}/request/commit")
-require File.expand_path("#{File.dirname(__FILE__)}/request/delete")
-require File.expand_path("#{File.dirname(__FILE__)}/request/ping")
-require File.expand_path("#{File.dirname(__FILE__)}/request/select")
-require File.expand_path("#{File.dirname(__FILE__)}/request/standard")
-require File.expand_path("#{File.dirname(__FILE__)}/request/spellcheck")
-require File.expand_path("#{File.dirname(__FILE__)}/request/dismax")
-require File.expand_path("#{File.dirname(__FILE__)}/request/index_info")
-require File.expand_path("#{File.dirname(__FILE__)}/request/optimize")
@@ -1,68 +0,0 @@
-# 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 File.expand_path(File.dirname(__FILE__) + '/json_update')
-
-class Solr::Request::AddDocument < Solr::Request::JsonUpdate
-
-  # 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
-
-  def to_json
-    '{' + 
-    @docs.map{ |doc| "\"add\": #{doc.to_jsonhash.to_json}" }.join(',') +
-    '}'
-  end
-
-  def to_xml
-    e = Solr::XML::Element.new 'add'
-    for doc in @docs
-      e.add_element doc.to_xml
-    end
-    return e.to_s
-  end
-
-  def to_s
-    to_json
-  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
@@ -1,36 +0,0 @@
-# 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
@@ -1,29 +0,0 @@
-# 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::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
@@ -1,48 +0,0 @@
-# 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::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
-
@@ -1,37 +0,0 @@
-# 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,
-                                       :alternate_query, :boost_query, :boost_functions])
-
-  def initialize(params)
-    super
-  end
-  
-  def to_hash
-    hash = super
-    hash[:defType] = 'edismax'
-    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[:boost]  = @params[:boost_functions]
-    hash["q.alt"] = @params[:alternate_query]
-
-    return hash
-  end
-
-end
@@ -1,22 +0,0 @@
-# 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
@@ -1,23 +0,0 @@
-# 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::JsonUpdate < Solr::Request::Base
-  def response_format
-    :xml
-  end
-
-  def handler
-    'update/json'
-  end
-end
@@ -1,46 +0,0 @@
-# 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::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
@@ -1,19 +0,0 @@
-# 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::Optimize < Solr::Request::Update
-
-  def to_s
-    Solr::XML::Element.new('optimize').to_s
-  end
-
-end
 \ No newline at end of file
@@ -1,36 +0,0 @@
-# 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
@@ -1,54 +0,0 @@
-# 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.
-
-# "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', 'json.nl' => 'arrarr'}.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
@@ -1,30 +0,0 @@
-# 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
@@ -1,408 +0,0 @@
-# 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, :radius, 
-    :radius, :latitude, :longitude, :spellcheck]
-  
-  def initialize(params)
-    super 'search'
-    
-    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
-    hash[:sort] = @params[:sort]
-    hash[:q] = @params[:query]
-    hash["q.op"] = @params[:operator]
-    hash[:df] = @params[:default_field]
-    hash[:echoParams] = 'explicit'
-
-    # 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?
-    
-    hash[:sfield] = 'latlng'
-    hash[:d] = @params[:radius]
-    hash[:pt] = "#{@params[:latitude]}, #{@params[:longitude]}" if @params[:latitude] and @params[:longitude]
-    
-    # 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]
-      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]
-            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[:spellcheck] = true
-    hash['spellcheck.collate'] = true
-    
-    hash.merge(super.to_hash)
-  end
-
-end
@@ -1,23 +0,0 @@
-# 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
@@ -1,27 +0,0 @@
-# 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 File.expand_path("#{File.dirname(__FILE__)}/response/base")
-require File.expand_path("#{File.dirname(__FILE__)}/response/xml")
-require File.expand_path("#{File.dirname(__FILE__)}/response/ruby")
-require File.expand_path("#{File.dirname(__FILE__)}/response/ping")
-require File.expand_path("#{File.dirname(__FILE__)}/response/add_document")
-require File.expand_path("#{File.dirname(__FILE__)}/response/modify_document")
-require File.expand_path("#{File.dirname(__FILE__)}/response/standard")
-require File.expand_path("#{File.dirname(__FILE__)}/response/spellcheck")
-require File.expand_path("#{File.dirname(__FILE__)}/response/dismax")
-require File.expand_path("#{File.dirname(__FILE__)}/response/commit")
-require File.expand_path("#{File.dirname(__FILE__)}/response/delete")
-require File.expand_path("#{File.dirname(__FILE__)}/response/index_info")
-require File.expand_path("#{File.dirname(__FILE__)}/response/optimize")
-require File.expand_path("#{File.dirname(__FILE__)}/response/select")
 \ No newline at end of file
@@ -1,17 +0,0 @@
-# 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
@@ -1,42 +0,0 @@
-# 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
@@ -1,15 +0,0 @@
-# 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::Commit < Solr::Response::Xml
-end
-
@@ -1,13 +0,0 @@
-# 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
@@ -1,8 +0,0 @@
-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
@@ -1,26 +0,0 @@
-# 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
@@ -1,17 +0,0 @@
-# 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
...	...	@@ -27,3 +27,5 @@
27	27	* rewrite conditional routing. See FIXME in lib/route_if.rb and re-implement using the Rails 3 mechanism - http://guides.rubyonrails.org/routing.html#advanced-constraints
28	28
29	29	* check FIXME's in config/environment.rb
	30	+
	31	+* xss_terminate sucks. We should replace it with the builtin mechanism in Rails 3
...	...
...	...	@@ -2,6 +2,8 @@ require 'hpricot'
2	2
3	3	class Article < ActiveRecord::Base
4	4
	5	+ attr_accessible :name, :body, :abstract, :profile
	6	+
5	7	# use for internationalizable human type names in search facets
6	8	# reimplement on subclasses
7	9	def self.type_name
...	...	@@ -142,7 +144,6 @@ class Article < ActiveRecord::Base
142	144	else
143	145	ArticleCategorization.add_category_to_article(c, self)
144	146	self.categories(reload)
145		- self.solr_save
146	147	end
147	148	end
148	149
...	...	@@ -160,7 +161,6 @@ class Article < ActiveRecord::Base
160	161	ArticleCategorization.add_category_to_article(item, self)
161	162	end
162	163	self.categories(true)
163		- self.solr_save
164	164	pending_categorizations.clear
165	165	end
166	166
...	...	@@ -238,7 +238,6 @@ class Article < ActiveRecord::Base
238	238	body \|\| ''
239	239	end
240	240
241		- include ApplicationHelper
242	241	def reported_version(options = {})
243	242	article = self
244	243	search_path = File.join(Rails.root, 'app', 'views', 'shared', 'reported_versions')
...	...	@@ -469,10 +468,6 @@ class Article < ActiveRecord::Base
469	468	allow_post_content?(user) \|\| user && allow_members_to_edit && user.is_member_of?(profile)
470	469	end
471	470
472		- def comments_updated
473		- solr_save
474		- end
475		-
476	471	def accept_category?(cat)
477	472	!cat.is_a?(ProductCategory)
478	473	end
...	...	@@ -636,21 +631,6 @@ class Article < ActiveRecord::Base
636	631
637	632	private
638	633
639		- # FIXME: workaround for development env.
640		- # Subclasses aren't (re)loaded, and acts_as_solr
641		- # depends on subclasses method to search
642		- # see http://stackoverflow.com/questions/4138957/activerecordsubclassnotfound-error-when-using-sti-in-rails/4139245
643		- UploadedFile
644		- TextArticle
645		- TinyMceArticle
646		- TextileArticle
647		- Folder
648		- EnterpriseHomepage
649		- Gallery
650		- Blog
651		- Forum
652		- Event
653		-
654	634	def self.f_type_proc(klass)
655	635	klass.constantize.type_name
656	636	end
...	...	@@ -682,9 +662,6 @@ class Article < ActiveRecord::Base
682	662	end
683	663
684	664	delegate :region, :region_id, :environment, :environment_id, :to => :profile, :allow_nil => true
685		- def name_sortable # give a different name for solr
686		- name
687		- end
688	665
689	666	def public
690	667	self.public?
...	...	@@ -694,39 +671,6 @@ class Article < ActiveRecord::Base
694	671	categories_including_virtual_ids
695	672	end
696	673
697		- public
698		-
699		- acts_as_faceted :fields => {
700		- :f_type => {:label => _('Type'), :proc => proc{\|klass\| f_type_proc(klass)}},
701		- :f_published_at => {:type => :date, :label => _('Published date'), :queries => {'[* TO NOW-1YEARS/DAY]' => _("Older than one year"),
702		- '[NOW-1YEARS TO NOW/DAY]' => _("In the last year"), '[NOW-1MONTHS TO NOW/DAY]' => _("In the last month"), '[NOW-7DAYS TO NOW/DAY]' => _("In the last week"), '[NOW-1DAYS TO NOW/DAY]' => _("In the last day")},
703		- :queries_order => ['[NOW-1DAYS TO NOW/DAY]', '[NOW-7DAYS TO NOW/DAY]', '[NOW-1MONTHS TO NOW/DAY]', '[NOW-1YEARS TO NOW/DAY]', '[* TO NOW-1YEARS/DAY]']},
704		- :f_profile_type => {:label => _('Profile'), :proc => proc{\|klass\| f_profile_type_proc(klass)}},
705		- :f_category => {:label => _('Categories')},
706		- }, :category_query => proc { \|c\| "category_filter:\"#{c.id}\"" },
707		- :order => [:f_type, :f_published_at, :f_profile_type, :f_category]
708		-
709		- acts_as_searchable :fields => facets_fields_for_solr + [
710		- # searched fields
711		- {:name => {:type => :text, :boost => 2.0}},
712		- {:slug => :text}, {:body => :text},
713		- {:abstract => :text}, {:filename => :text},
714		- # filtered fields
715		- {:public => :boolean}, {:environment_id => :integer},
716		- {:profile_id => :integer}, :language,
717		- {:category_filter => :integer},
718		- # ordered/query-boosted fields
719		- {:name_sortable => :string}, :last_changed_by_id, :published_at, :is_image,
720		- :updated_at, :created_at,
721		- ], :include => [
722		- {:profile => {:fields => [:name, :identifier, :address, :nickname, :region_id, :lat, :lng]}},
723		- {:comments => {:fields => [:title, :body, :author_name, :author_email]}},
724		- {:categories => {:fields => [:name, :path, :slug, :lat, :lng, :acronym, :abbreviation]}},
725		- ], :facets => facets_option_for_solr,
726		- :boost => proc { \|a\| 10 if a.profile && a.profile.enabled },
727		- :if => proc{ \|a\| ! ['RssFeed'].include?(a.class.name) }
728		- handle_asynchronously :solr_save
729		-
730	674	private
731	675
732	676	def sanitize_tag_list
...	...
...	...	@@ -2,7 +2,7 @@ class BlogArchivesBlock < Block
2	2
3	3	include ActionView::Helpers::TagHelper
4	4	include ActionView::Helpers::UrlHelper
5		- include ActionController::UrlWriter
	5	+ include Rails.application.routes.url_helpers
6	6	include ActionView::Helpers::AssetTagHelper
7	7	include DatesHelper
8	8
...	...
...	...	@@ -90,23 +90,4 @@ class Category < ActiveRecord::Base
90	90	self.children.find(:all, :conditions => {:display_in_menu => true}).empty?
91	91	end
92	92
93		- private
94		- def name_sortable # give a different name for solr
95		- name
96		- end
97		- public
98		-
99		- acts_as_searchable :fields => [
100		- # searched fields
101		- {:name => {:type => :text, :boost => 2.0}},
102		- {:path => :text}, {:slug => :text},
103		- {:abbreviation => :text}, {:acronym => :text},
104		- # filtered fields
105		- :parent_id,
106		- # ordered/query-boosted fields
107		- {:name_sortable => :string},
108		- ]
109		- after_save_reindex [:articles, :profiles], :with => :delayed_job
110		- handle_asynchronously :solr_save
111		-
112	93	end
...	...
...	...	@@ -24,6 +24,4 @@ class Certifier < ActiveRecord::Base
24	24	self.name.downcase.transliterate <=> b.name.downcase.transliterate
25	25	end
26	26
27		- after_save_reindex [:products], :with => :delayed_job
28		-
29	27	end
...	...
...	...	@@ -80,7 +80,7 @@ class ChangePassword < Task
80	80	_('Your password was changed successfully.')
81	81	end
82	82
83		- include ActionController::UrlWriter
	83	+ include Rails.application.routes.url_helpers
84	84	def task_created_message
85	85	hostname = self.requestor.environment.default_hostname
86	86	code = self.code
...	...
...	...	@@ -14,7 +14,6 @@ class Enterprise < Organization
14	14
15	15	has_and_belongs_to_many :fans, :class_name => 'Person', :join_table => 'favorite_enteprises_people'
16	16
17		- after_save_reindex [:products], :with => :delayed_job
18	17	extra_data_for_index :product_categories
19	18	def product_categories
20	19	products.includes(:product_category).map{\|p\| p.category_full_name}.compact
...	...
...	...	@@ -764,18 +764,49 @@ class Environment < ActiveRecord::Base
764	764	after_create :create_templates
765	765
766	766	def create_templates
767		- pre = self.name.to_slug + '_'
768		- ent_id = Enterprise.create!(:name => 'Enterprise template', :identifier => pre + 'enterprise_template', :environment => self, :visible => false, :is_template => true).id
769		- inactive_enterprise_tmpl = Enterprise.create!(:name => 'Inactive Enterprise template', :identifier => pre + 'inactive_enterprise_template', :environment => self, :visible => false, :is_template => true)
770		- com_id = Community.create!(:name => 'Community template', :identifier => pre + 'community_template', :environment => self, :visible => false, :is_template => true).id
	767	+ prefix = self.name.to_slug + '_'
	768	+
	769	+ enterprise_template = Enterprise.new(
	770	+ :name => 'Enterprise template',
	771	+ :identifier => prefix + 'enterprise_template'
	772	+ )
	773	+
	774	+ inactive_enterprise_template = Enterprise.new(
	775	+ :name => 'Inactive Enterprise template',
	776	+ :identifier => prefix + 'inactive_enterprise_template'
	777	+ )
	778	+
	779	+ community_template = Community.new(
	780	+ :name => 'Community template',
	781	+ :identifier => prefix + 'community_template'
	782	+ )
	783	+
	784	+ [
	785	+ enterprise_template,
	786	+ inactive_enterprise_template,
	787	+ community_template
	788	+ ].each do \|profile\|
	789	+ profile.is_template = true
	790	+ profile.visible = false
	791	+ profile.environment = self
	792	+ profile.save!
	793	+ end
	794	+
771	795	pass = Digest::MD5.hexdigest rand.to_s
772		- user = User.create!(:login => (pre + 'person_template'), :email => (pre + 'template@template.noo'), :password => pass, :password_confirmation => pass, :environment => self).person
773		- user.update_attributes(:visible => false, :name => "Person template", :is_template => true)
774		- usr_id = user.id
775		- self.settings[:enterprise_template_id] = ent_id
776		- self.inactive_enterprise_template = inactive_enterprise_tmpl
777		- self.settings[:community_template_id] = com_id
778		- self.settings[:person_template_id] = usr_id
	796	+ user = User.new(:login => (prefix + 'person_template'), :email => (prefix + 'template@template.noo'), :password => pass, :password_confirmation => pass)
	797	+ user.environment = self
	798	+ user.save!
	799	+
	800	+ person_template = user.person
	801	+ person_template.name = "Person template"
	802	+ person_template.is_template = true
	803	+ person_template.visible = false
	804	+ person_template.save!
	805	+
	806	+ self.enterprise_template = enterprise_template
	807	+ self.inactive_enterprise_template = inactive_enterprise_template
	808	+ self.community_template = community_template
	809	+ self.person_template = person_template
779	810	self.save!
780	811	end
781	812
...	...	@@ -788,14 +819,20 @@ class Environment < ActiveRecord::Base
788	819
789	820	after_create :create_default_licenses
790	821	def create_default_licenses
791		- License.create!(:name => 'CC (by)', :url => 'http://creativecommons.org/licenses/by/3.0/legalcode', :environment => self)
792		- License.create!(:name => 'CC (by-nd)', :url => 'http://creativecommons.org/licenses/by-nd/3.0/legalcode', :environment => self)
793		- License.create!(:name => 'CC (by-sa)', :url => 'http://creativecommons.org/licenses/by-sa/3.0/legalcode', :environment => self)
794		- License.create!(:name => 'CC (by-nc)', :url => 'http://creativecommons.org/licenses/by-nc/3.0/legalcode', :environment => self)
795		- License.create!(:name => 'CC (by-nc-nd)', :url => 'http://creativecommons.org/licenses/by-nc-nd/3.0/legalcode', :environment => self)
796		- License.create!(:name => 'CC (by-nc-sa)', :url => 'http://creativecommons.org/licenses/by-nc-sa/3.0/legalcode', :environment => self)
797		- License.create!(:name => 'Free Art', :url => 'http://artlibre.org/licence/lal/en', :environment => self)
798		- License.create!(:name => 'GNU FDL', :url => 'http://www.gnu.org/licenses/fdl-1.3.txt', :environment => self)
	822	+ [
	823	+ { :name => 'CC (by)', :url => 'http://creativecommons.org/licenses/by/3.0/legalcode'},
	824	+ { :name => 'CC (by-nd)', :url => 'http://creativecommons.org/licenses/by-nd/3.0/legalcode'},
	825	+ { :name => 'CC (by-sa)', :url => 'http://creativecommons.org/licenses/by-sa/3.0/legalcode'},
	826	+ { :name => 'CC (by-nc)', :url => 'http://creativecommons.org/licenses/by-nc/3.0/legalcode'},
	827	+ { :name => 'CC (by-nc-nd)', :url => 'http://creativecommons.org/licenses/by-nc-nd/3.0/legalcode'},
	828	+ { :name => 'CC (by-nc-sa)', :url => 'http://creativecommons.org/licenses/by-nc-sa/3.0/legalcode'},
	829	+ { :name => 'Free Art', :url => 'http://artlibre.org/licence/lal/en'},
	830	+ { :name => 'GNU FDL', :url => 'http://www.gnu.org/licenses/fdl-1.3.txt'},
	831	+ ].each do \|data\|
	832	+ license = License.new(data)
	833	+ license.environment = self
	834	+ license.save!
	835	+ end
799	836	end
800	837
801	838	def highlighted_products_with_image(options = {})
...	...
1	1	class License < ActiveRecord::Base
	2	+
	3	+ attr_accessible :name, :url
	4	+
2	5	belongs_to :environment
3	6	has_many :content, :class_name => 'Article', :foreign_key => 'license_id'
4	7
...	...
1	1	class LinkListBlock < Block
2	2
	3	+ attr_accessible :links
	4	+
3	5	ICONS = [
4	6	['no-icon', _('(No icon)')],
5	7	['edit', N_('Edit')],
...	...