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	9	production:
10	10	url: http://127.0.0.1:8983/solr
11	11	jvm_options: -server -Xmx192M -Xms64M
12		- timeout: 0
	12	+ timeout: 600
13	13	data_path: /var/lib/noosfero-data/solr/index
14	14
15	15	development:
16	16	url: http://0.0.0.0:8982/solr
17	17	jvm_options: -server -Xmx128M -Xms16M
18		- timeout: 0
	18	+ timeout: 600
19	19
20	20	test: &TEST
21	21	url: http://0.0.0.0:8981/solr
22	22	jvm_options: -server -Xmx128M -Xms16M
23		- timeout: 0
	23	+ timeout: 600
24	24
25	25	cucumber:
26	26	<<: *TEST
...	...
1		-raise "Not ready yet. Some tests are failing."
	1	+#raise "Not ready yet. Some tests are failing."
2	2	require 'rubygems'
3	3	require 'rake'
4	4
...	...
...	...	@@ -27,7 +27,8 @@ class Product
27	27	{:name => {:type => :text, :boost => 2.0}},
28	28	{:description => :text}, {:category_full_name => :text},
29	29	# filtered fields
30		- {:solr_plugin_public => :boolean}, {:environment_id => :integer},
	30	+ {:solr_plugin_public => :boolean},
	31	+ {:environment_id => :integer}, {:profile_id => :integer},
31	32	{:enabled => :boolean}, {:solr_plugin_category_filter => :integer},
32	33	# ordered/query-boosted fields
33	34	{:solr_plugin_price_sortable => :decimal}, {:solr_plugin_name_sortable => :string},
...	...
...	...	@@ -42,7 +42,7 @@ class Profile
42	42	handle_asynchronously :solr_save
43	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	46	self.solr_plugin_extra_index_methods = []
47	47
48	48	def solr_plugin_extra_data_for_index
...	...
...	...	@@ -33,8 +33,8 @@ class SolrPlugin < Noosfero::Plugin
33	33
34	34	solr_options = solr_options(class_asset(klass), category)
35	35	solr_options[:filter_queries] \|\|= []
36		- solr_options[:filter_queries] += scopes_to_solr_filters scope, klass, options
37		- solr_options.merge! products_options(user) if klass == Product and empty_query
	36	+ solr_options[:filter_queries] += scopes_to_solr_options scope, klass, options
	37	+ solr_options.merge! products_options(user) if asset == :products and empty_query
38	38	solr_options.merge! options.except(:category, :filter)
39	39
40	40	scope.find_by_contents query, paginate_options, solr_options
...	...	@@ -42,14 +42,14 @@ class SolrPlugin < Noosfero::Plugin
42	42
43	43	protected
44	44
45		- def scopes_to_solr_filters scope, klass = nil, options = {}
	45	+ def scopes_to_solr_options scope, klass = nil, options = {}
46	46	filter_queries = []
47	47	klass \|\|= scope.base_class
48	48	solr_fields = klass.configuration[:solr_fields].keys
49	49	scopes_applied = scope.scopes_applied.dup rescue [] #rescue association and class direct filtering
50	50
51		- scope.current_scoped_methods[:create].each do \|attr, value\|
52		- next unless solr_fields.include? attr.to_sym
	51	+ scope.scope_attributes.each do \|attr, value\|
	52	+ raise "Non-indexed attribute '#{attr}' speficied in scope_attributes" unless solr_fields.include? attr.to_sym
53	53
54	54	# if the filter is present here, then prefer it
55	55	scopes_applied.reject!{ \|name\| name == attr.to_sym }
...	...
	1	+services:
	2	+ - mongodb
	3	+
	4	+language: ruby
	5	+rvm:
	6	+ - 1.8.7
	7	+
	8	+before_install:
	9	+ - sudo apt-get update
	10	+ - sudo apt-get install default-jdk
	11	+
1	12	before_script:
2	13	- mongo mydb_test --eval 'db.addUser("travis", "test");'
3	14	- gem update --system 1.4.1 > /dev/null 2>&1
4	15	- rake solr:download
5	16	- RAILS_ENV=test rake solr:start
6	17
7		-script: "bundle exec rake $TASK --trace"
	18	+script:
	19	+ - bundle exec rake test --trace
	20	+ - bundle exec rake test:functional --trace
8	21
9		-rvm:
10		- - 1.8.7
11		-env:
12		- - TASK=test
13		- - TASK=test:functional
...	...
1		-source :rubygems
	1	+source 'https://rubygems.org'
2	2
3	3	gem 'ruby-debug'
	4	+gem 'rdoc'
	5	+
	6	+gem 'jeweler'
4	7
5	8	gem 'rails', '2.3.5'
6	9
...	...
1	1	require 'rubygems'
2	2	require 'rake'
3	3	require 'rake/testtask'
4		-require 'rake/rdoctask'
	4	+require 'rdoc/task'
5	5
6	6	ENV['RAILS_ENV'] = "test"
7	7	require File.expand_path("#{File.dirname(__FILE__)}/config/solr_environment")
8	8
9	9	Dir["#{File.dirname(__FILE__)}/lib/tasks/*.rake"].sort.each { \|ext\| load ext }
10	10
11		-desc "Default Task"
12		-task :default => [:test]
13		-
14		-desc "Runs the unit tests"
15		-task :test => "test:unit"
16		-
17		-namespace :test do
18		- task :setup do
19		- DB \|\|= 'sqlite'
20		- puts "Using " + DB
21		- %x(mysql -u#{MYSQL_USER} < #{File.dirname(__FILE__) + "/test/fixtures/db_definitions/mysql.sql"}) if DB == 'mysql'
22		-
23		- Rake::Task["test:migrate"].invoke
24		- end
25		-
26		- desc 'Measures test coverage using rcov'
27		- task :rcov => :setup do
28		- rm_f "coverage"
29		- rm_f "coverage.data"
30		- rcov = "rcov --rails --aggregate coverage.data --text-summary -Ilib"
31		-
32		- system("#{rcov} --html #{Dir.glob('test/*/_shoulda.rb').join(' ')}")
33		- system("open coverage/index.html") if PLATFORM['darwin']
34		- end
35		-
36		- desc 'Runs the functional tests, testing integration with Solr'
37		- Rake::TestTask.new(:functional => :setup) do \|t\|
38		- t.pattern = "test/functional/*_test.rb"
39		- t.verbose = true
40		- end
41		-
42		- desc "Unit tests"
43		- Rake::TestTask.new(:unit => :setup) do \|t\|
44		- t.libs << 'test/unit'
45		- t.pattern = "test/unit/*_shoulda.rb"
46		- t.verbose = true
47		- end
48		-end
49		-
50		-Rake::RDocTask.new do \|rd\|
51		- rd.main = "README.rdoc"
52		- rd.rdoc_dir = "rdoc"
53		- rd.rdoc_files.exclude("lib/solr/*/.rb", "lib/solr.rb")
54		- rd.rdoc_files.include("README.rdoc", "lib/*/.rb")
55		-end
56		-
57		-begin
58		- require 'jeweler'
59		- Jeweler::Tasks.new do \|s\|
60		- s.name = "acts_as_solr_reloaded"
61		- s.summary = "This gem adds full text search capabilities and many other nifty features from Apache Solr to any Rails model."
62		- s.email = "dc.rec1@gmail.com"
63		- s.homepage = "http://github.com/dcrec1/acts_as_solr_reloaded"
64		- s.description = "This gem adds full text search capabilities and many other nifty features from Apache Solr to any Rails model."
65		- s.authors = ["Diego Carrion"]
66		- s.files = FileList["[A-Z]", "{bin,generators,config,lib,solr}//"] +
67		- FileList["test/*/"].reject {\|f\| f.include?("test/log")}.reject {\|f\| f.include?("test/tmp")}
68		- end
69		-rescue LoadError
70		- puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install jeweler"
71		-end
...	...
...	...	@@ -6,23 +6,19 @@ require 'net/http'
6	6
7	7	dir = File.dirname(__FILE__)
8	8	SOLR_PATH = File.expand_path("#{dir}/../solr") unless defined? SOLR_PATH
9		-config = YAML::load_file(RAILS_ROOT+'/plugins/solr/config/solr.yml')
	9	+config = YAML::load_file("#{Rails.root}/plugins/solr/config/solr.yml")
10	10
11		-unless defined? RAILS_ROOT
12		- # define RAILS_ROOT for test environment
13		- RAILS_ROOT = defined?(Rails) ? Rails.root : File.expand_path("#{File.dirname(__FILE__)}/../test")
14		-end
15	11	unless defined? RAILS_ENV
16	12	RAILS_ENV = ENV['RAILS_ENV']
17	13	end
18	14	unless defined? SOLR_LOGS_PATH
19		- SOLR_LOGS_PATH = ENV["SOLR_LOGS_PATH"] \|\| "#{RAILS_ROOT}/log"
	15	+ SOLR_LOGS_PATH = ENV["SOLR_LOGS_PATH"] \|\| "#{Rails.root}/log"
20	16	end
21	17	unless defined? SOLR_PIDS_PATH
22		- SOLR_PIDS_PATH = ENV["SOLR_PIDS_PATH"] \|\| "#{RAILS_ROOT}/tmp/pids"
	18	+ SOLR_PIDS_PATH = ENV["SOLR_PIDS_PATH"] \|\| "#{Rails.root}/tmp/pids"
23	19	end
24	20	unless defined? SOLR_DATA_PATH
25		- SOLR_DATA_PATH = ENV["SOLR_DATA_PATH"] \|\| config[ENV['RAILS_ENV']]['data_path'] \|\| "#{RAILS_ROOT}/solr/#{ENV['RAILS_ENV']}"
	21	+ SOLR_DATA_PATH = ENV["SOLR_DATA_PATH"] \|\| config[ENV['RAILS_ENV']]['data_path'] \|\| "#{Rails.root}/solr/#{ENV['RAILS_ENV']}"
26	22	end
27	23	unless defined? SOLR_CONFIG_PATH
28	24	SOLR_CONFIG_PATH = ENV["SOLR_CONFIG_PATH"] \|\| "#{SOLR_PATH}/solr"
...	...
...	...	@@ -20,6 +20,7 @@ require File.dirname(__FILE__) + '/acts_as_solr/search_results'
20	20	require File.dirname(__FILE__) + '/acts_as_solr/lazy_document'
21	21	require File.dirname(__FILE__) + '/acts_as_solr/mongo_mapper'
22	22	require File.dirname(__FILE__) + '/acts_as_solr/post'
	23	+require File.dirname(__FILE__) + '/acts_as_solr/scope_with_applied_names'
23	24
24	25	# reopen ActiveRecord and include the acts_as_solr method
25	26	ActiveRecord::Base.extend ActsAsSolr::ActsMethods
...	...