Merge branch 'ai3293' into 'master'

Upgrade solr plugin to rails3 http://noosfero.org/Development/ActionItem3293 See merge request !321

Merge branch 'ai3293' into 'master'
Upgrade solr plugin to rails3 http://noosfero.org/Development/ActionItem3293 See merge request !321
Antonio Terceiro
2 parents df002879 b1d08c1c
Showing 28 changed files with 351 additions and 302 deletions Show diff stats
plugins/solr/config/solr.yml.dist
plugins/solr/install.rb
plugins/solr/lib/ext/product.rb
plugins/solr/lib/ext/profile.rb
plugins/solr/lib/solr_plugin.rb
plugins/solr/vendor/plugins/acts_as_solr_reloaded/.travis.yml
plugins/solr/vendor/plugins/acts_as_solr_reloaded/Gemfile
plugins/solr/vendor/plugins/acts_as_solr_reloaded/Rakefile
plugins/solr/vendor/plugins/acts_as_solr_reloaded/config/solr_environment.rb
plugins/solr/vendor/plugins/acts_as_solr_reloaded/lib/acts_as_solr.rb
plugins/solr/vendor/plugins/acts_as_solr_reloaded/lib/acts_as_solr/acts_methods.rb
plugins/solr/vendor/plugins/acts_as_solr_reloaded/lib/acts_as_solr/common_methods.rb
plugins/solr/vendor/plugins/acts_as_solr_reloaded/lib/acts_as_solr/parser_methods.rb
plugins/solr/vendor/plugins/acts_as_solr_reloaded/lib/acts_as_solr/scope_with_applied_names.rb
plugins/solr/vendor/plugins/acts_as_solr_reloaded/lib/solr/request/dismax.rb
plugins/solr/vendor/plugins/acts_as_solr_reloaded/lib/solr/request/standard.rb
plugins/solr/vendor/plugins/acts_as_solr_reloaded/lib/solr/response/ruby.rb
plugins/solr/vendor/plugins/acts_as_solr_reloaded/lib/solr/response/xml.rb
plugins/solr/vendor/plugins/acts_as_solr_reloaded/lib/tasks/database.rake
plugins/solr/vendor/plugins/acts_as_solr_reloaded/lib/tasks/jeweler.rake
@@ -9,18 +9,18 @@
 production:
   url: http://127.0.0.1:8983/solr
   jvm_options: -server -Xmx192M -Xms64M
-  timeout: 0
+  timeout: 600
   data_path: /var/lib/noosfero-data/solr/index
 development:
   url: http://0.0.0.0:8982/solr
   jvm_options: -server -Xmx128M -Xms16M
-  timeout: 0
+  timeout: 600
 test: &TEST
   url: http://0.0.0.0:8981/solr
   jvm_options: -server -Xmx128M -Xms16M
-  timeout: 0
+  timeout: 600
 cucumber:
   <<: *TEST
-raise "Not ready yet. Some tests are failing."
+#raise "Not ready yet. Some tests are failing."
 require 'rubygems'
 require 'rake'
@@ -27,7 +27,8 @@ class Product
       {:name => {:type => :text, :boost => 2.0}},
       {:description => :text}, {:category_full_name => :text},
       # filtered fields
-      {:solr_plugin_public => :boolean}, {:environment_id => :integer},
+      {:solr_plugin_public => :boolean},
+      {:environment_id => :integer}, {:profile_id => :integer},
       {:enabled => :boolean}, {:solr_plugin_category_filter => :integer},
       # ordered/query-boosted fields
       {:solr_plugin_price_sortable => :decimal}, {:solr_plugin_name_sortable => :string},
@@ -42,7 +42,7 @@ class Profile
   handle_asynchronously :solr_save
   handle_asynchronously :solr_destroy
-  class_inheritable_accessor :solr_plugin_extra_index_methods
+  class_attribute :solr_plugin_extra_index_methods
   self.solr_plugin_extra_index_methods = []
   def solr_plugin_extra_data_for_index
@@ -33,8 +33,8 @@ class SolrPlugin &lt; Noosfero::Plugin
     solr_options = solr_options(class_asset(klass), category)
     solr_options[:filter_queries] ||= []
-    solr_options[:filter_queries] += scopes_to_solr_filters scope, klass, options
-    solr_options.merge! products_options(user) if klass == Product and empty_query
+    solr_options[:filter_queries] += scopes_to_solr_options scope, klass, options
+    solr_options.merge! products_options(user) if asset == :products and empty_query
     solr_options.merge! options.except(:category, :filter)
     scope.find_by_contents query, paginate_options, solr_options
@@ -42,14 +42,14 @@ class SolrPlugin &lt; Noosfero::Plugin
   protected
-  def scopes_to_solr_filters scope, klass = nil, options = {}
+  def scopes_to_solr_options scope, klass = nil, options = {}
     filter_queries = []
     klass ||= scope.base_class
     solr_fields = klass.configuration[:solr_fields].keys
     scopes_applied = scope.scopes_applied.dup rescue [] #rescue association and class direct filtering
-    scope.current_scoped_methods[:create].each do |attr, value|
-      next unless solr_fields.include? attr.to_sym
+    scope.scope_attributes.each do |attr, value|
+      raise "Non-indexed attribute '#{attr}' speficied in scope_attributes" unless solr_fields.include? attr.to_sym
       # if the filter is present here, then prefer it
       scopes_applied.reject!{ |name| name == attr.to_sym }
+services: 
+  - mongodb
+
+language: ruby
+rvm:
+  - 1.8.7
+
+before_install:
+  - sudo apt-get update
+  - sudo apt-get install default-jdk
+
 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"
+script: 
+  - bundle exec rake test --trace
+  - bundle exec rake test:functional --trace
-rvm:
-  - 1.8.7
-env: 
-  - TASK=test
-  - TASK=test:functional
-source :rubygems
+source 'https://rubygems.org'
 gem 'ruby-debug'
+gem 'rdoc'
+
+gem 'jeweler'
 gem 'rails', '2.3.5'
 require 'rubygems'
 require 'rake'
 require 'rake/testtask'
-require 'rake/rdoctask'
+require 'rdoc/task'
 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
@@ -6,23 +6,19 @@ require &#39;net/http&#39;
 dir = File.dirname(__FILE__)
 SOLR_PATH = File.expand_path("#{dir}/../solr") unless defined? SOLR_PATH
-config = YAML::load_file(RAILS_ROOT+'/plugins/solr/config/solr.yml')
+config = YAML::load_file("#{Rails.root}/plugins/solr/config/solr.yml")
-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"
+  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"
+  SOLR_PIDS_PATH = ENV["SOLR_PIDS_PATH"] || "#{Rails.root}/tmp/pids"
 end
 unless defined? SOLR_DATA_PATH
-  SOLR_DATA_PATH = ENV["SOLR_DATA_PATH"] || config[ENV['RAILS_ENV']]['data_path'] || "#{RAILS_ROOT}/solr/#{ENV['RAILS_ENV']}"
+  SOLR_DATA_PATH = ENV["SOLR_DATA_PATH"] || config[ENV['RAILS_ENV']]['data_path'] || "#{Rails.root}/solr/#{ENV['RAILS_ENV']}"
 end
 unless defined? SOLR_CONFIG_PATH
   SOLR_CONFIG_PATH = ENV["SOLR_CONFIG_PATH"] || "#{SOLR_PATH}/solr"
@@ -20,6 +20,7 @@ require File.dirname(__FILE__) + &#39;/acts_as_solr/search_results&#39;
 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'
+require File.dirname(__FILE__) + '/acts_as_solr/scope_with_applied_names'
 # reopen ActiveRecord and include the acts_as_solr method
 ActiveRecord::Base.extend ActsAsSolr::ActsMethods
@@ -178,6 +178,8 @@ module ActsAsSolr #:nodoc:
       include CommonMethods
       include ParserMethods
+      attr_accessor :solr_score
+
       define_solr_configuration_methods
       acts_as_taggable_on :tags if options[:taggable]
 module ActsAsSolr #:nodoc:
-  
+
   module CommonMethods
     TypeMapping = {
@@ -14,6 +14,7 @@ module ActsAsSolr #:nodoc:
       :range_integer => "ri",
       :facet => "facet",
       :text => "t",
+      :ngram_text => "nt",
     }
     # Converts field types into Solr types
@@ -39,39 +40,39 @@ module ActsAsSolr #:nodoc:
       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 
+    #
+    # 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 
+    #
+    # 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}"
+    def record_id object
+      object.send object.class.primary_key
     end
   end
 end
@@ -4,12 +4,16 @@ module ActsAsSolr #:nodoc:
     # 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,
+      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,]
+        :offset, :per_page, :limit, :page,
+        :query_fields, :default_field,
+      ]
       query_options = {}
       options[:results_format] ||= :objects
+      options[:default_field] ||= 'text'
       return if query.nil?
       raise "Query should be a string" unless query.is_a?(String)
@@ -49,77 +53,95 @@ module ActsAsSolr #:nodoc:
         query_options[:rows] = per_page
         query_options[:start] = offset
+        query_options[:boost_functions] = replace_types([*options[:boost_functions]], '').join(' ') if options[:boost_functions]
+
+        parse_facets query_options, options
+        parse_highlight query_options, options
+        parse_sort query_options, options
+        parse_location query_options, options
+        parse_query_fields query_options, options
+
         query_options[:operator] = options[:operator]
+        not_dismax = query_options[:operator] == :or
+        request = if not_dismax then Solr::Request::Standard.new(query_options) else Solr::Request::Dismax.new query_options end
+        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
-        query_options[:boost_functions] = replace_types([*options[:boost_functions]], '').join(' ') if options[:boost_functions]
+    def parse_query_fields query_options, options
+      options[:query_fields] ||= []
+      query_options[:query_fields] = replace_types([*options[:query_fields]], '').join ' '
+    end
+
+    def parse_sort query_options, options
+      query_options[:sort] = replace_types([*options[:sort]], '')[0] if options[:sort]
+    end
-        # 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
+    def parse_location query_options, options
+      if options[:radius]
+        query_options[:radius] = options[:radius]
+        query_options[:filter_queries] << '{!geofilt}'
+      end
+      query_options[:latitude] = options[:latitude]
+      query_options[:longitude] = options[:longitude]
+    end
+    def parse_highlight query_options, options
+      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
+    end
+
+    def parse_facets query_options, options
+      # 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
-        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[: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]
-        query_options[:sort] = replace_types([*options[:sort]], '')[0] if options[:sort]
+          if options[:facets][:dates][:other]
+            validate_date_facet_other_options(options[:facets][:dates][:other])
+            query_options[:date_facets][:other] = options[:facets][:dates][:other]
+          end
-        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
@@ -148,21 +170,21 @@ module ActsAsSolr #:nodoc:
         results.update :start => header['params']['start']
       end
-      results.update(:facets => {'facet_fields' => []}) if options[:facets]
+      results.update(:facets => {'facet_fields' => {}}) if options[:facets]
       return SearchResults.new(results) if solr_data.total_hits == 0
       results.update(:facets => solr_data.data['facet_counts']) if options[:facets]
-      ids = solr_data.hits.collect {|doc| doc["#{solr_configuration[:primary_key_field]}"]}.flatten
-      result = find_objects(ids, options)
-      results.update(:docs => result)
+      ids = solr_data.hits.collect{ |doc| doc["#{solr_configuration[:primary_key_field]}"] }.flatten
+      result = find_objects ids, options
+      results.update :ids => ids, :docs => result
       add_scores(result, solr_data) if options[:results_format] == :objects and options[:scores]
       highlighted = {}
       solr_data.highlighting.map do |x,y|
         e={}
-        y1=y.map{|x1,y1| e[x1.gsub(/_[^_]*/,"")]=y1} unless y.nil?
+        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(:highlights => highlighted)
@@ -179,8 +201,12 @@ module ActsAsSolr #:nodoc:
         ids.collect{ |id| ActsAsSolr::LazyDocument.new(id, self) }
       elsif options[:results_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) || []
+        if Rails::VERSION::STRING >= '3.0'
+          result = self.scoped(find_options).where(self.primary_key => ids).all
+        else
+          find_options[:conditions] = self.send :merge_conditions, {self.primary_key => ids}, (find_options[:conditions] || [])
+          result = self.all(find_options)
+        end
         result = reorder(result, ids) unless find_options[:order]
         result
       elsif options[:results_format] == :none
@@ -226,22 +252,15 @@ module ActsAsSolr #:nodoc:
     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
+        record = results.find do |result|
+          doc_id = doc["#{solr_configuration[:primary_key_field]}"].first rescue nil
+          record_id(result).to_s == doc_id
+        end
+        with_score.push [doc["score"], record]
       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
+      with_score.each do |score, record|
+        next unless record
+        record.solr_score = score
       end
     end
@@ -0,0 +1,91 @@
+
+if Rails::VERSION::STRING >= "3.2"
+  module ::ActiveRecord
+
+    class Relation
+      attr_accessor :scopes_applied
+    end
+
+    module Scoping
+      module Named
+        module ClassMethods
+          attr_accessor :scope_name, :scopes_applied
+
+          def scope_with_applied_names name, scope_options = {}
+            name = name.to_sym
+            valid_scope_name?(name)
+            extension = Module.new(&Proc.new) if block_given?
+
+            scope_proc = lambda do |*args|
+              options = scope_options.respond_to?(:call) ? unscoped { scope_options.call(*args) } : scope_options
+              options = scoped.apply_finder_options(options) if options.is_a?(Hash)
+
+              relation = scoped.merge(options)
+              relation.scopes_applied ||= Set.new
+              relation.scopes_applied << name
+
+              extension ? relation.extending(extension) : relation
+            end
+
+            singleton_class.send(:redefine_method, name, &scope_proc)
+          end
+          alias_method_chain :scope, :applied_names
+
+        end
+      end
+    end
+  end
+else
+  require_dependency 'active_record/named_scope'
+
+  module ::ActiveRecord
+    module NamedScope
+      module ClassMethods
+
+        def named_scope_with_applied_names name, options = {}, &block
+          named_scope_without_applied_names name, options, &block
+
+          name = name.to_sym
+          scopes[name] = lambda do |parent_scope, *args|
+            scope = Scope.new(parent_scope, case options
+            when Hash
+              options
+            when Proc
+              if self.model_name != parent_scope.model_name
+                options.bind(parent_scope).call(*args)
+              else
+                options.call(*args)
+              end
+            end, &block)
+            scope.scope_name = name
+            scope
+          end
+        end
+        alias_method_chain :named_scope, :applied_names
+      end
+
+      class Scope
+        attr_accessor :scope_name, :scopes_applied
+
+        def initialize_with_applied_names proxy_scope, options, &block
+          initialize_without_applied_names proxy_scope, options, &block
+          self.scopes_applied ||= []
+          self.scopes_applied += proxy_scope.send :scopes_applied if Scope === proxy_scope
+
+          # unrelated bugfix: use if instead of unless
+          if (Scope === proxy_scope || ActiveRecord::Associations::AssociationCollection === proxy_scope)
+            @current_scoped_methods_when_defined = proxy_scope.send(:current_scoped_methods)
+          end
+        end
+        alias_method_chain :initialize, :applied_names
+
+        def scope_name= name
+          @scope_name = name
+          self.scopes_applied << @scope_name
+        end
+
+      end
+
+    end
+  end
+end
@@ -12,13 +12,15 @@
 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])
+  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'
@@ -12,40 +12,42 @@
 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]
-  
+  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 
+
+    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 
+      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]
@@ -61,11 +63,11 @@ class Solr::Request::Standard &lt; Solr::Request::Select
     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
@@ -95,7 +97,7 @@ class Solr::Request::Standard &lt; Solr::Request::Select
           end
         end
       end
-      
+
       if @params[:date_facets]
         hash["facet.date"] = []
         if @params[:date_facets][:fields]
@@ -125,7 +127,7 @@ class Solr::Request::Standard &lt; Solr::Request::Select
         end
       end
     end
-    
+
     # highlighting parameter processing - http://wiki.apache.org/solr/HighlightingParameters
     if @params[:highlighting]
       hash[:hl] = true
@@ -385,7 +387,7 @@ class Solr::Request::Standard &lt; Solr::Request::Select
       end
     end
-    
+
     if @params[:mlt]
       hash[:mlt] = true
       hash["mlt.count"] = @params[:mlt][:count]
@@ -398,10 +400,10 @@ class Solr::Request::Standard &lt; Solr::Request::Select
       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
@@ -14,13 +14,14 @@ class Solr::Response::Ruby &lt; Solr::Response::Base
   attr_reader :data, :header
   def initialize(ruby_code)
+    ruby_code.force_encoding('UTF-8') if RUBY_VERSION >= '1.9'
     super
     begin
       #TODO: what about pulling up data/header/response to ResponseBase,
       #      or maybe a new middle class like SelectResponseBase since
       #      all Select queries return this same sort of stuff??
       #      XML (&wt=xml) and Ruby (&wt=ruby) responses contain exactly the same structure.
-      #      a goal of solrb is to make it irrelevant which gets used under the hood, 
+      #      a goal of solrb is to make it irrelevant which gets used under the hood,
       #      but favor Ruby responses.
       @data = eval(ruby_code)
       @header = @data['responseHeader']
@@ -38,5 +39,5 @@ class Solr::Response::Ruby &lt; Solr::Response::Base
   def query_time
     @header['QTime']
   end
-  
+
 end
@@ -18,7 +18,7 @@ class Solr::Response::Xml &lt; Solr::Response::Base
     # parse the xml
     @doc = REXML::Document.new(xml)
-    # look for the result code and string 
+    # look for the result code and string
     # <?xml version="1.0" encoding="UTF-8"?>
     # <response>
     # <lst name="responseHeader"><int name="status">0</int><int name="QTime">2</int></lst>
@@ -5,12 +5,12 @@ namespace :db do
       begin
         ActsAsSolr::Post.execute(Solr::Request::Delete.new(:query => "*:*"))
         ActsAsSolr::Post.execute(Solr::Request::Commit.new)
-        (ENV['FIXTURES'] ? ENV['FIXTURES'].split(/,/) : Dir.glob(File.join(RAILS_ROOT, 'test', 'fixtures', '*.{yml,csv}'))).each do |fixture_file|    
+        (ENV['FIXTURES'] ? ENV['FIXTURES'].split(/,/) : Dir.glob(File.join(Rails.root, 'test', 'fixtures', '*.{yml,csv}'))).each do |fixture_file|
           ActsAsSolr::SolrFixtures.load(File.basename(fixture_file, '.*'))
-        end 
-        puts "The fixtures loaded have been added to Solr"       
+        end
+        puts "The fixtures loaded have been added to Solr"
       rescue
       end
     end
   end
-end
 \ No newline at end of file
+end
@@ -0,0 +1,15 @@
+begin
+  require 'jeweler'
+rescue LoadError
+end
+
+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 if defined? Jeweler
@@ -0,0 +1,10 @@
+require 'rake/testtask'
+require 'rdoc/task'
+
+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
+
@@ -158,7 +158,7 @@ namespace :solr do
     logger = ActiveRecord::Base.logger = Logger.new(STDOUT)
     logger.level = ActiveSupport::BufferedLogger::INFO unless debug_output
-    Dir["#{RAILS_ROOT}/app/models/*.rb"].each{ |file| require file }
+    Dir["#{Rails.root}/app/models/*.rb"].each{ |file| require file }
     if start_server
       puts "Starting Solr server..."
@@ -1,5 +0,0 @@
-namespace :test do
-  task :migrate do
-    ActiveRecord::Migrator.migrate("test/db/migrate/", ENV["VERSION"] ? ENV["VERSION"].to_i : nil)
-  end
-end
@@ -57,11 +57,9 @@
     <fieldType name="text"     class="solr.TextField" autoGeneratePhraseQueries="false">
       <analyzer type="index">
         <tokenizer class="solr.StandardTokenizerFactory"/>
-        <filter class="solr.RemoveDuplicatesTokenFilterFactory"/>
-
         <filter class="solr.ASCIIFoldingFilterFactory"/>
         <filter class="solr.LowerCaseFilterFactory"/>
-
+        <filter class="solr.RemoveDuplicatesTokenFilterFactory"/>
         <filter class="solr.StopFilterFactory" words="stopwords.pt.txt" />
         <!-- stemming
@@ -73,18 +71,12 @@
         <filter class="solr.HunspellStemFilterFactory" dictionary="en_US.dic" affix="en_US.aff" ignoreCase="true" />
         <filter class="solr.HunspellStemFilterFactory" dictionary="pt_PT.dic" affix="pt_PT.aff" ignoreCase="true" />
         -->
-
-        <!-- improvised stemming
-        <filter class="solr.EdgeNGramFilterFactory" minGramSize="3" maxGramSize="20" side="front"/>
-        -->
       </analyzer>
       <analyzer type="query">
         <tokenizer class="solr.StandardTokenizerFactory"/>
-        <filter class="solr.RemoveDuplicatesTokenFilterFactory"/>
-
         <filter class="solr.ASCIIFoldingFilterFactory"/>
         <filter class="solr.LowerCaseFilterFactory"/>
-
+        <filter class="solr.RemoveDuplicatesTokenFilterFactory"/>
         <filter class="solr.StopFilterFactory" words="stopwords.pt.txt" />
         <!-- stemming
@@ -96,10 +88,23 @@
         <filter class="solr.HunspellStemFilterFactory" dictionary="en_US.dic" affix="en_US.aff" ignoreCase="true" />
         <filter class="solr.HunspellStemFilterFactory" dictionary="pt_PT.dic" affix="pt_PT.aff" ignoreCase="true" />
         -->
+      </analyzer>
+    </fieldType>
-        <!-- improvised stemming
-        <filter class="solr.EdgeNGramFilterFactory" minGramSize="3" maxGramSize="20" side="front"/>
-        -->
+    <fieldType name="ngramText" class="solr.TextField" positionIncrementGap="100">
+      <analyzer type="index">
+        <tokenizer class="solr.StandardTokenizerFactory"/>
+        <filter class="solr.ASCIIFoldingFilterFactory"/>
+        <filter class="solr.LowerCaseFilterFactory"/>
+        <filter class="solr.RemoveDuplicatesTokenFilterFactory"/>
+
+        <filter class="solr.EdgeNGramFilterFactory" minGramSize="1" maxGramSize="20" side="front"/>
+      </analyzer>
+      <analyzer type="query">
+        <tokenizer class="solr.StandardTokenizerFactory"/>
+        <filter class="solr.ASCIIFoldingFilterFactory"/>
+        <filter class="solr.LowerCaseFilterFactory"/>
+        <filter class="solr.RemoveDuplicatesTokenFilterFactory"/>
       </analyzer>
     </fieldType>
@@ -151,6 +156,7 @@
    <dynamicField name="*sortable_do"        type="sdouble"   indexed="true"  stored="false" multiValued="false"/>
    <dynamicField name="*_t"                 type="text"      indexed="true"  stored="true"  multiValued="true"/>
+   <dynamicField name="*_nt"                type="ngramText" indexed="true"  stored="true"  multiValued="true"/>
    <dynamicField name="*_s"                 type="text"      indexed="true"  stored="true"  multiValued="false"/>
    <dynamicField name="*_i"                 type="integer"   indexed="true"  stored="false" multiValued="true"/>
    <dynamicField name="*_f"                 type="float"     indexed="true"  stored="true"  multiValued="false"/>
@@ -168,6 +174,7 @@
    <field        name="geo_distance"        type="sdouble"/> <!-- Optional but used for distributed searching -->
    <field        name="text"                type="text"      indexed="true"  stored="false" multiValued="true"/>
+   <field        name="ngramText"           type="ngramText" indexed="true"  stored="false" multiValued="true"/>
    <field        name="spell"               type="textSpell" indexed="true"  stored="true"  multiValued="true"/>
    <dynamicField name="*_s_mv"              type="string"    indexed="true"  stored="false" multiValued="true"/>
@@ -187,6 +194,10 @@
  <copyField source="*_do"    dest="text"/>
  <copyField source="*_facet" dest="text"/>
+ <copyField source="*_s"     dest="ngramText"/>
+ <copyField source="*_t"     dest="ngramText"/>
+ <copyField source="*_nt"    dest="ngramText"/>
+
  <copyField source="*_s"     dest="spell"/>
  <copyField source="*_t"     dest="spell"/>
  <copyField source="*_facet" dest="spell"/>
@@ -2,5 +2,4 @@ require &#39;rubygems&#39;
 require 'rake'
 dir = File.dirname(__FILE__)
 $:.unshift("#{dir}/lib")
-RAILS_ROOT = dir
 require "acts_as_solr/tasks"
@@ -0,0 +1,9 @@
+home:
+  id: 1
+  longitude: -77.4027
+  latitude: 39.36
+  
+work:
+  id: 2
+  longitude: -77.4027
+  latitude: 38.36
@@ -16,7 +16,7 @@ require &#39;mongo_mapper&#39;
 class Rails
   def self.root
-    RAILS_ROOT
+    Rails.root
   end
   def self.env
@@ -26,13 +26,14 @@ end
 MongoMapper.database = "acts_as_solr_reloaded-test"
-RAILS_ROOT = File.dirname(__FILE__) unless defined? RAILS_ROOT
-RAILS_ENV  = 'test' unless defined? RAILS_ENV
+RAILS_ENV = 'test' unless defined? RAILS_ENV
 ENV["RAILS_ENV"] = "test"
 require File.expand_path(File.dirname(__FILE__) + '/../config/solr_environment')
 require File.expand_path(File.dirname(__FILE__) + '/../lib/acts_as_solr')
+ActiveRecord::Base.logger = Logger.new('/dev/null')
+
 # Load Models
 models_dir = File.join(File.dirname( __FILE__ ), 'models')
 require "#{models_dir}/book.rb"
@@ -60,10 +61,10 @@ class Test::Unit::TestCase
       klass = instance_eval table_name.to_s.capitalize.singularize
       klass.find(:all).each{|content| content.solr_save}
     end
-    
+
     clear_from_solr(:novels)
   end
-  
+
   private
   def self.clear_from_solr(table_name)
     ActsAsSolr::Post.execute(Solr::Request::Delete.new(:query => "type_s:#{table_name.to_s.capitalize.singularize}"))
@@ -1,57 +0,0 @@
-require_dependency 'active_record/named_scope'
-
-if Rails::VERSION::STRING < "2.3.99"
-
-  module ::ActiveRecord
-
-    module NamedScope
-
-      module ClassMethods
-
-        def named_scope_with_applied_names name, options = {}, &block
-          named_scope_without_applied_names name, options, &block
-
-          name = name.to_sym
-          scopes[name] = lambda do |parent_scope, *args|
-            scope = Scope.new(parent_scope, case options
-            when Hash
-              options
-            when Proc
-              if self.model_name != parent_scope.model_name
-                options.bind(parent_scope).call(*args)
-              else
-                options.call(*args)
-              end
-            end, &block)
-            scope.scope_name = name
-            scope
-          end
-        end
-        alias_method_chain :named_scope, :applied_names
-      end
-
-      class Scope
-        attr_accessor :scope_name, :scopes_applied
-
-        def initialize_with_applied_names proxy_scope, options, &block
-          initialize_without_applied_names proxy_scope, options, &block
-          self.scopes_applied ||= []
-          self.scopes_applied += proxy_scope.send :scopes_applied if Scope === proxy_scope
-
-          # unrelated bugfix: use if instead of unless
-          if (Scope === proxy_scope || ActiveRecord::Associations::AssociationCollection === proxy_scope)
-            @current_scoped_methods_when_defined = proxy_scope.send(:current_scoped_methods)
-          end
-        end
-        alias_method_chain :initialize, :applied_names
-
-        def scope_name= name
-          @scope_name = name
-          self.scopes_applied << @scope_name
-        end
-
-      end
-
-    end
-  end
-end
	@@ -9,18 +9,18 @@		@@ -9,18 +9,18 @@
9	production:	9	production:
10	url: http://127.0.0.1:8983/solr	10	url: http://127.0.0.1:8983/solr
11	jvm_options: -server -Xmx192M -Xms64M	11	jvm_options: -server -Xmx192M -Xms64M
12	- timeout: 0	12	+ timeout: 600
13	data_path: /var/lib/noosfero-data/solr/index	13	data_path: /var/lib/noosfero-data/solr/index
14		14
15	development:	15	development:
16	url: http://0.0.0.0:8982/solr	16	url: http://0.0.0.0:8982/solr
17	jvm_options: -server -Xmx128M -Xms16M	17	jvm_options: -server -Xmx128M -Xms16M
18	- timeout: 0	18	+ timeout: 600
19		19
20	test: &TEST	20	test: &TEST
21	url: http://0.0.0.0:8981/solr	21	url: http://0.0.0.0:8981/solr
22	jvm_options: -server -Xmx128M -Xms16M	22	jvm_options: -server -Xmx128M -Xms16M
23	- timeout: 0	23	+ timeout: 600
24		24
25	cucumber:	25	cucumber:
26	<<: *TEST	26	<<: *TEST
1	-raise "Not ready yet. Some tests are failing."	1	+#raise "Not ready yet. Some tests are failing."
2	require 'rubygems'	2	require 'rubygems'
3	require 'rake'	3	require 'rake'
4		4
	@@ -42,7 +42,7 @@ class Profile		@@ -42,7 +42,7 @@ class Profile
42	handle_asynchronously :solr_save	42	handle_asynchronously :solr_save
43	handle_asynchronously :solr_destroy	43	handle_asynchronously :solr_destroy
44		44
45	- class_inheritable_accessor :solr_plugin_extra_index_methods	45	+ class_attribute :solr_plugin_extra_index_methods
46	self.solr_plugin_extra_index_methods = []	46	self.solr_plugin_extra_index_methods = []
47		47
48	def solr_plugin_extra_data_for_index	48	def solr_plugin_extra_data_for_index
1	-source :rubygems	1	+source 'https://rubygems.org'
2		2
3	gem 'ruby-debug'	3	gem 'ruby-debug'
		4	+gem 'rdoc'
		5	+
		6	+gem 'jeweler'
4		7
5	gem 'rails', '2.3.5'	8	gem 'rails', '2.3.5'
6		9
	@@ -20,6 +20,7 @@ require File.dirname(__FILE__) + '/acts_as_solr/search_results'		@@ -20,6 +20,7 @@ require File.dirname(__FILE__) + '/acts_as_solr/search_results'
20	require File.dirname(__FILE__) + '/acts_as_solr/lazy_document'	20	require File.dirname(__FILE__) + '/acts_as_solr/lazy_document'
21	require File.dirname(__FILE__) + '/acts_as_solr/mongo_mapper'	21	require File.dirname(__FILE__) + '/acts_as_solr/mongo_mapper'
22	require File.dirname(__FILE__) + '/acts_as_solr/post'	22	require File.dirname(__FILE__) + '/acts_as_solr/post'
		23	+require File.dirname(__FILE__) + '/acts_as_solr/scope_with_applied_names'
23		24
24	# reopen ActiveRecord and include the acts_as_solr method	25	# reopen ActiveRecord and include the acts_as_solr method
25	ActiveRecord::Base.extend ActsAsSolr::ActsMethods	26	ActiveRecord::Base.extend ActsAsSolr::ActsMethods
	@@ -178,6 +178,8 @@ module ActsAsSolr #:nodoc:		@@ -178,6 +178,8 @@ module ActsAsSolr #:nodoc:
178	include CommonMethods	178	include CommonMethods
179	include ParserMethods	179	include ParserMethods
180		180
		181	+ attr_accessor :solr_score
		182	+
181	define_solr_configuration_methods	183	define_solr_configuration_methods
182		184
183	acts_as_taggable_on :tags if options[:taggable]	185	acts_as_taggable_on :tags if options[:taggable]
@@ -0,0 +1,91 @@		@@ -0,0 +1,91 @@
	1	+
	2	+if Rails::VERSION::STRING >= "3.2"
	3	+ module ::ActiveRecord
	4	+
	5	+ class Relation
	6	+ attr_accessor :scopes_applied
	7	+ end
	8	+
	9	+ module Scoping
	10	+ module Named
	11	+ module ClassMethods
	12	+ attr_accessor :scope_name, :scopes_applied
	13	+
	14	+ def scope_with_applied_names name, scope_options = {}
	15	+ name = name.to_sym
	16	+ valid_scope_name?(name)
	17	+ extension = Module.new(&Proc.new) if block_given?
	18	+
	19	+ scope_proc = lambda do \|*args\|
	20	+ options = scope_options.respond_to?(:call) ? unscoped { scope_options.call(*args) } : scope_options
	21	+ options = scoped.apply_finder_options(options) if options.is_a?(Hash)
	22	+
	23	+ relation = scoped.merge(options)
	24	+ relation.scopes_applied \|\|= Set.new
	25	+ relation.scopes_applied << name
	26	+
	27	+ extension ? relation.extending(extension) : relation
	28	+ end
	29	+
	30	+ singleton_class.send(:redefine_method, name, &scope_proc)
	31	+ end
	32	+ alias_method_chain :scope, :applied_names
	33	+
	34	+ end
	35	+ end
	36	+ end
	37	+ end
	38	+else
	39	+ require_dependency 'active_record/named_scope'
	40	+
	41	+ module ::ActiveRecord
	42	+ module NamedScope
	43	+ module ClassMethods
	44	+
	45	+ def named_scope_with_applied_names name, options = {}, &block
	46	+ named_scope_without_applied_names name, options, &block
	47	+
	48	+ name = name.to_sym
	49	+ scopes[name] = lambda do \|parent_scope, *args\|
	50	+ scope = Scope.new(parent_scope, case options
	51	+ when Hash
	52	+ options
	53	+ when Proc
	54	+ if self.model_name != parent_scope.model_name
	55	+ options.bind(parent_scope).call(*args)
	56	+ else
	57	+ options.call(*args)
	58	+ end
	59	+ end, &block)
	60	+ scope.scope_name = name
	61	+ scope
	62	+ end
	63	+ end
	64	+ alias_method_chain :named_scope, :applied_names
	65	+ end
	66	+
	67	+ class Scope
	68	+ attr_accessor :scope_name, :scopes_applied
	69	+
	70	+ def initialize_with_applied_names proxy_scope, options, &block
	71	+ initialize_without_applied_names proxy_scope, options, &block
	72	+ self.scopes_applied \|\|= []
	73	+ self.scopes_applied += proxy_scope.send :scopes_applied if Scope === proxy_scope
	74	+
	75	+ # unrelated bugfix: use if instead of unless
	76	+ if (Scope === proxy_scope \|\| ActiveRecord::Associations::AssociationCollection === proxy_scope)
	77	+ @current_scoped_methods_when_defined = proxy_scope.send(:current_scoped_methods)
	78	+ end
	79	+ end
	80	+ alias_method_chain :initialize, :applied_names
	81	+
	82	+ def scope_name= name
	83	+ @scope_name = name
	84	+ self.scopes_applied << @scope_name
	85	+ end
	86	+
	87	+ end
	88	+
	89	+ end
	90	+ end
	91	+end
	@@ -18,7 +18,7 @@ class Solr::Response::Xml < Solr::Response::Base		@@ -18,7 +18,7 @@ class Solr::Response::Xml < Solr::Response::Base
18	# parse the xml	18	# parse the xml
19	@doc = REXML::Document.new(xml)	19	@doc = REXML::Document.new(xml)
20		20
21	- # look for the result code and string	21	+ # look for the result code and string
22	# <?xml version="1.0" encoding="UTF-8"?>	22	# <?xml version="1.0" encoding="UTF-8"?>
23	# <response>	23	# <response>
24	# <lst name="responseHeader"><int name="status">0</int><int name="QTime">2</int></lst>	24	# <lst name="responseHeader"><int name="status">0</int><int name="QTime">2</int></lst>
@@ -0,0 +1,15 @@		@@ -0,0 +1,15 @@
	1	+begin
	2	+ require 'jeweler'
	3	+rescue LoadError
	4	+end
	5	+
	6	+Jeweler::Tasks.new do \|s\|
	7	+ s.name = "acts_as_solr_reloaded"
	8	+ s.summary = "This gem adds full text search capabilities and many other nifty features from Apache Solr to any Rails model."
	9	+ s.email = "dc.rec1@gmail.com"
	10	+ s.homepage = "http://github.com/dcrec1/acts_as_solr_reloaded"
	11	+ s.description = "This gem adds full text search capabilities and many other nifty features from Apache Solr to any Rails model."
	12	+ s.authors = ["Diego Carrion"]
	13	+ s.files = FileList["[A-Z]", "{bin,generators,config,lib,solr}//"] +
	14	+ FileList["test/*/"].reject {\|f\| f.include?("test/log")}.reject {\|f\| f.include?("test/tmp")}
	15	+end if defined? Jeweler
@@ -0,0 +1,10 @@		@@ -0,0 +1,10 @@
	1	+require 'rake/testtask'
	2	+require 'rdoc/task'
	3	+
	4	+Rake::RDocTask.new do \|rd\|
	5	+ rd.main = "README.rdoc"
	6	+ rd.rdoc_dir = "rdoc"
	7	+ rd.rdoc_files.exclude("lib/solr/*/.rb", "lib/solr.rb")
	8	+ rd.rdoc_files.include("README.rdoc", "lib/*/.rb")
	9	+end
	10	+