acts_as_solr_reloaded 1.4.0 → 1.5.0

data/VERSION

@@ -1 +1 @@
-1.4.0
+1.5.0

data/lib/acts_as_solr.rb

@@ -1,23 +1,3 @@
-# Copyright (c) 2006 Erik Hatcher, Thiago Jackiw
-#
-# Permission is hereby granted, free of charge, to any person obtaining a copy
-# of this software and associated documentation files (the "Software"), to deal
-# in the Software without restriction, including without limitation the rights
-# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-# copies of the Software, and to permit persons to whom the Software is
-# furnished to do so, subject to the following conditions:
-#
-# The above copyright notice and this permission notice shall be included in all
-# copies or substantial portions of the Software.
-#
-# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-# SOFTWARE.
-
 require 'active_record'
 require 'rexml/document'
 require 'net/http'
@@ -39,32 +19,21 @@ require File.dirname(__FILE__) + '/acts_as_solr/deprecation'
 require File.dirname(__FILE__) + '/acts_as_solr/search_results'
 require File.dirname(__FILE__) + '/acts_as_solr/lazy_document'
 require File.dirname(__FILE__) + '/acts_as_solr/mongo_mapper'
+
 module ActsAsSolr
-  
+
   class Post    
     def self.execute(request, core = nil)
-      begin
-        if File.exists?(RAILS_ROOT+'/config/solr.yml')
-          config = YAML::load_file(RAILS_ROOT+'/config/solr.yml')
-          url = config[ENV['RAILS_ENV']]['url']
-          # for backwards compatibility
-          url ||= "http://#{config[ENV['RAILS_ENV']]['host']}:#{config[ENV['RAILS_ENV']]['port']}/#{config[ENV['RAILS_ENV']]['servlet_path']}"
-        else
-          url = 'http://localhost:8982/solr'
-        end
-        url += "/" + core if !core.nil?
-        connection = Solr::Connection.new(url,
-            :username=>config[ENV['RAILS_ENV']]['username'],
-            :password=>config[ENV['RAILS_ENV']]['password'])
-        return connection.send(request)
-      rescue 
-        raise "Couldn't connect to the Solr server at #{url}. #{$!}"
-        false
-      end
+      config_file_path = File.join(Rails.root, '/config/solr.yml')
+      config = YAML::load_file(config_file_path)[Rails.env]
+      url = config['url'] + (core.nil? ? '' : "/#{core}")
+      connection = Solr::Connection.new(url,
+                                        :username => config['username'],
+                                        :password => config['password'])
+      connection.send request
     end
   end
-  
 end
 
 # reopen ActiveRecord and include the acts_as_solr method
-ActiveRecord::Base.extend ActsAsSolr::ActsMethods
+ActiveRecord::Base.extend ActsAsSolr::ActsMethods

data/test/unit/parser_methods_shoulda.rb

@@ -112,240 +112,240 @@ class ParserMethodsTest < Test::Unit::TestCase
         should "create LazyDocuments for the resulting docs" do
           result = @parser.parse_results(@results, :lazy => true)
           assert_equal ActsAsSolr::LazyDocument, result.results.first.class
-        end
-
-        should "set the document id as the record id" do
-          result = @parser.parse_results(@results, :lazy => true)
-          assert_equal 1, result.results.first.id
-        end
+      end
 
-        should "set the document class" do
-          result = @parser.parse_results(@results, :lazy => true)
-          assert_equal ActsAsSolr::ParserInstance, result.results.first.clazz.class
-        end
+      should "set the document id as the record id" do
+        result = @parser.parse_results(@results, :lazy => true)
+        assert_equal 1, result.results.first.id
       end
 
+      should "set the document class" do
+        result = @parser.parse_results(@results, :lazy => true)
+        assert_equal ActsAsSolr::ParserInstance, result.results.first.clazz.class
+      end
     end
 
-    context "when reordering results" do
-      should "raise an error if arguments don't have the same number of elements" do
-        assert_raise(RuntimeError) {@parser.reorder([], [1])}
-      end
+  end
 
-      should "reorder the results to match the order of the documents returned by solr" do
-        thing1 = stub(:thing1)
-        thing1.stubs(:id).returns 5
-        thing2 = stub(:thing2)
-        thing2.stubs(:id).returns 1
-        thing3 = stub(:things3)
-        thing3.stubs(:id).returns 3
-        things = [thing1, thing2, thing3]
-        reordered = @parser.reorder(things, ['1', '3', '5'])
-        assert_equal [1, 3, 5], reordered.collect{|thing| thing.id}
-      end
+  context "when reordering results" do
+    should "raise an error if arguments don't have the same number of elements" do
+      assert_raise(RuntimeError) {@parser.reorder([], [1])}
     end
 
-    context "When parsing a query" do
-      setup do
-        ActsAsSolr::Post.stubs(:execute)
-        @parser.stubs(:solr_type_condition).returns "(type:ParserMethodsTest)"
-        @parser.solr_configuration = {:primary_key_field => "id"}
-        @parser.configuration = {:solr_fields => nil}
-      end
+    should "reorder the results to match the order of the documents returned by solr" do
+      thing1 = stub(:thing1)
+      thing1.stubs(:id).returns 5
+      thing2 = stub(:thing2)
+      thing2.stubs(:id).returns 1
+      thing3 = stub(:things3)
+      thing3.stubs(:id).returns 3
+      things = [thing1, thing2, thing3]
+      reordered = @parser.reorder(things, ['1', '3', '5'])
+      assert_equal [1, 3, 5], reordered.collect{|thing| thing.id}
+    end
+  end
 
-      should "set the limit and offset" do
-        ActsAsSolr::Post.expects(:execute).with {|request, core|
-          10 == request.to_hash[:rows]
-          20 == request.to_hash[:start]
-        }
-        @parser.parse_query "foo", :limit => 10, :offset => 20
-      end
+  context "When parsing a query" do
+    setup do
+      ActsAsSolr::Post.stubs(:execute)
+      @parser.stubs(:solr_type_condition).returns "(type:ParserMethodsTest)"
+      @parser.solr_configuration = {:primary_key_field => "id"}
+      @parser.configuration = {:solr_fields => nil}
+    end
 
-      should "set the relevancy of the specified fields and non-filtered terms" do
-        expected = "(aeroplane brasil continent_t:south OR tag_t:(aeroplane brasil)^5 OR description_t:(aeroplane brasil)^3)"
-        ActsAsSolr::Post.expects(:execute).with {|request, core|
-          request.to_hash[:q].starts_with? expected
-        }
-        @parser.parse_query "aeroplane brasil continent:south", :relevance => {:tag => 5, :description => 3}
-      end
+    should "set the limit and offset" do
+      ActsAsSolr::Post.expects(:execute).with {|request, core|
+        10 == request.to_hash[:rows]
+        20 == request.to_hash[:start]
+      }
+      @parser.parse_query "foo", :limit => 10, :offset => 20
+    end
 
-      should "set the relevance unless no query specified" do
-        expected = "(continent_t:south)"
-        ActsAsSolr::Post.expects(:execute).with {|request, core|
-          request.to_hash[:q].starts_with? expected
-        }
-        @parser.parse_query "continent:south", :relevance => {:tag => 5, :description => 3}
-      end
+    should "set the relevancy of the specified fields and non-filtered terms" do
+      ActsAsSolr::Post.expects(:execute).with {|request, core|
+        q = request.to_hash[:q]
+        q.starts_with?("(aeroplane brasil continent_t:south OR tag_t:(aeroplane brasil)^5 OR description_t:(aeroplane brasil)^3)") or q.starts_with?("(aeroplane brasil continent_t:south OR description_t:(aeroplane brasil)^3 OR tag_t:(aeroplane brasil)^5)")
+      }
+      @parser.parse_query "aeroplane brasil continent:south", :relevance => {:tag => 5, :description => 3}
+    end
 
-      should "set the relevance with simple queries" do
-        expected = "(car OR tag_t:(car)^5 OR description_t:(car)^3)"
-        ActsAsSolr::Post.expects(:execute).with {|request, core|
-          request.to_hash[:q].starts_with? expected
-        }
-        @parser.parse_query "car", :relevance => {:tag => 5, :description => 3}
-      end
+    should "set the relevance unless no query specified" do
+      expected = "(continent_t:south)"
+      ActsAsSolr::Post.expects(:execute).with {|request, core|
+        request.to_hash[:q].starts_with? expected
+      }
+      @parser.parse_query "continent:south", :relevance => {:tag => 5, :description => 3}
+    end
 
-      should "not execute anything if the query is nil" do
-        ActsAsSolr::Post.expects(:execute).never
-        assert_nil @parser.parse_query(nil)
-      end
+    should "set the relevance with simple queries" do
+      ActsAsSolr::Post.expects(:execute).with {|request, core|
+        q = request.to_hash[:q]
+        q.starts_with?("(car OR tag_t:(car)^5 OR description_t:(car)^3)") or q.starts_with?("(car OR description_t:(car)^3 OR tag_t:(car)^5)")
+      }
+      @parser.parse_query "car", :relevance => {:tag => 5, :description => 3}
+    end
 
-      should "not execute anything if the query is ''" do
-        ActsAsSolr::Post.expects(:execute).never
-        assert_nil @parser.parse_query('')
-      end
+    should "not execute anything if the query is nil" do
+      ActsAsSolr::Post.expects(:execute).never
+      assert_nil @parser.parse_query(nil)
+    end
 
-      should "raise an error if invalid options where specified" do
-        assert_raise(RuntimeError) {@parser.parse_query "foo", :invalid => true}
-      end
+    should "not execute anything if the query is ''" do
+      ActsAsSolr::Post.expects(:execute).never
+      assert_nil @parser.parse_query('')
+    end
 
-      should "add the type" do
-        ActsAsSolr::Post.expects(:execute).with {|request, core|
-          request.to_hash[:q].include?("(type:ParserMethodsTest)")
-        }
-        @parser.parse_query "foo"
-      end
+    should "raise an error if invalid options where specified" do
+      assert_raise(RuntimeError) {@parser.parse_query "foo", :invalid => true}
+    end
 
-      should "append the field types for the specified fields" do
-        ActsAsSolr::Post.expects(:execute).with {|request, core|
-          request.to_hash[:q].include?("(username_t:Chunky)")
-        }
-        @parser.parse_query "username:Chunky"
-      end
+    should "add the type" do
+      ActsAsSolr::Post.expects(:execute).with {|request, core|
+        request.to_hash[:q].include?("(type:ParserMethodsTest)")
+      }
+      @parser.parse_query "foo"
+    end
 
-      should "replace the field types" do
-        @parser.expects(:replace_types).returns(["active_i:1"])
-        ActsAsSolr::Post.expects(:execute).with {|request, core|
-          request.to_hash[:q].include?("active_i:1")
-        }
-        @parser.parse_query "active:1"
-      end
+    should "append the field types for the specified fields" do
+      ActsAsSolr::Post.expects(:execute).with {|request, core|
+        request.to_hash[:q].include?("(username_t:Chunky)")
+      }
+      @parser.parse_query "username:Chunky"
+  end
 
-      should "add score and primary key to field list" do
-        ActsAsSolr::Post.expects(:execute).with {|request, core|
-          request.to_hash[:fl] == ('id,score')
-        }
-        @parser.parse_query "foo"
-      end
+  should "replace the field types" do
+    @parser.expects(:replace_types).returns(["active_i:1"])
+    ActsAsSolr::Post.expects(:execute).with {|request, core|
+      request.to_hash[:q].include?("active_i:1")
+    }
+    @parser.parse_query "active:1"
+  end
 
-      should "add highlight options" do
-        ActsAsSolr::Post.expects(:execute).with {|request, core|
-          request.to_hash[:hl] == "true"
-          request.to_hash["hl.fl"] == "title_t"
-        }
-        @parser.parse_query "car", :highlight => {:fields => "title"}
-      end
+  should "add score and primary key to field list" do
+    ActsAsSolr::Post.expects(:execute).with {|request, core|
+      request.to_hash[:fl] == ('id,score')
+    }
+    @parser.parse_query "foo"
+  end
+
+  should "add highlight options" do
+    ActsAsSolr::Post.expects(:execute).with {|request, core|
+      request.to_hash[:hl] == "true"
+      request.to_hash["hl.fl"] == "title_t"
+    }
+    @parser.parse_query "car", :highlight => {:fields => "title"}
+  end
 
-      should "set the operator" do
-        ActsAsSolr::Post.expects(:execute).with {|request, core|
+  should "set the operator" do
+    ActsAsSolr::Post.expects(:execute).with {|request, core|
           "OR" == request.to_hash["q.op"]
-      }
-        @parser.parse_query "foo", :operator => :or
-      end
-      
-      should "activate spellcheck" do
-        ActsAsSolr::Post.expects(:execute).with {|request, core|
-          request.to_hash[:spellcheck] == true
-        }
-        @parser.parse_query "foo"
-      end
-      
-      should "activate spellcheck collation" do
-        ActsAsSolr::Post.expects(:execute).with {|request, core|
-          request.to_hash['spellcheck.collate'] == true
-        }
-        @parser.parse_query "foo"
-      end
+    }
+    @parser.parse_query "foo", :operator => :or
+  end
 
-      context "with the around option" do
-        should "set the qt as geo" do
-          ActsAsSolr::Post.expects(:execute).with {|request, core|
-            request.to_hash[:qt] == ('geo')
-          }
-          @parser.parse_query "foo" , :around => {:latitude => '-39.36',
-                                                  :longitude => '77.4027',
-                                                  :radius => 1}
-        end
+  should "activate spellcheck" do
+    ActsAsSolr::Post.expects(:execute).with {|request, core|
+      request.to_hash[:spellcheck] == true
+    }
+    @parser.parse_query "foo"
+  end
 
-        should "set the radius" do
-          ActsAsSolr::Post.expects(:execute).with {|request, core|
-            request.to_hash[:radius] == 12
-          }
-          @parser.parse_query "foo" , :around => {:latitude => '-39.36',
-                                                  :longitude => '77.4027',
-                                                  :radius => 12}
-        end
+  should "activate spellcheck collation" do
+    ActsAsSolr::Post.expects(:execute).with {|request, core|
+      request.to_hash['spellcheck.collate'] == true
+    }
+    @parser.parse_query "foo"
+  end
 
-        should "set the latitude" do
-          ActsAsSolr::Post.expects(:execute).with {|request, core|
-            request.to_hash[:lat] == '-39.36'
-          }
-          @parser.parse_query "foo" , :around => {:latitude => '-39.36',
-                                                  :longitude => '77.4027',
-                                                  :radius => 12}
-        end
+  context "with the around option" do
+    should "set the qt as geo" do
+      ActsAsSolr::Post.expects(:execute).with {|request, core|
+        request.to_hash[:qt] == ('geo')
+      }
+      @parser.parse_query "foo" , :around => {:latitude => '-39.36',
+        :longitude => '77.4027',
+        :radius => 1}
+    end
 
-        should "set the longitude" do
-          ActsAsSolr::Post.expects(:execute).with {|request, core|
-            request.to_hash[:long] == '77.4027'
-          }
-          @parser.parse_query "foo" , :around => {:latitude => '-39.36',
-                                                  :longitude => '77.4027',
-                                                  :radius => 12}
-        end
-      end
+    should "set the radius" do
+      ActsAsSolr::Post.expects(:execute).with {|request, core|
+        request.to_hash[:radius] == 12
+      }
+      @parser.parse_query "foo" , :around => {:latitude => '-39.36',
+        :longitude => '77.4027',
+        :radius => 12}
+    end
 
-      context "with the order option" do
-        should "add the order criteria to the query" do
-          ActsAsSolr::Post.expects(:execute).with {|request, core|
-            request.to_hash[:sort].include?("active_t desc")
-          }
-          @parser.parse_query "active:1", :order => "active desc"
-        end
-      end
+    should "set the latitude" do
+      ActsAsSolr::Post.expects(:execute).with {|request, core|
+        request.to_hash[:lat] == '-39.36'
+      }
+      @parser.parse_query "foo" , :around => {:latitude => '-39.36',
+        :longitude => '77.4027',
+        :radius => 12}
+    end
 
-      context "with facets" do
-      end
+    should "set the longitude" do
+      ActsAsSolr::Post.expects(:execute).with {|request, core|
+        request.to_hash[:long] == '77.4027'
+      }
+      @parser.parse_query "foo" , :around => {:latitude => '-39.36',
+        :longitude => '77.4027',
+        :radius => 12}
     end
+  end
 
-    context "When setting the field types" do
-      setup do
-        @parser.configuration = {:solr_fields => {:name => {:type => :string},
-                                          :age => {:type => :integer}}}
-      end
+  context "with the order option" do
+    should "add the order criteria to the query" do
+      ActsAsSolr::Post.expects(:execute).with {|request, core|
+        request.to_hash[:sort].include?("active_t desc")
+      }
+      @parser.parse_query "active:1", :order => "active desc"
+    end
+  end
 
-      should "replace the _t suffix with the real type" do
-        assert_equal ["name_s:Chunky AND age_i:21"], @parser.replace_types(["name_t:Chunky AND age_t:21"])
-      end
+  context "with facets" do
+  end
+end
 
-      context "with a suffix" do
-        should "not include the colon when false" do
-          assert_equal ["name_s"], @parser.replace_types(["name_t"], false)
-        end
+context "When setting the field types" do
+  setup do
+    @parser.configuration = {:solr_fields => {:name => {:type => :string},
+      :age => {:type => :integer}}}
+  end
 
-        should "include the colon by default" do
-          assert_equal ["name_s:Chunky"], @parser.replace_types(["name_t:Chunky"])
-        end
-      end
+  should "replace the _t suffix with the real type" do
+    assert_equal ["name_s:Chunky AND age_i:21"], @parser.replace_types(["name_t:Chunky AND age_t:21"])
+  end
+
+  context "with a suffix" do
+    should "not include the colon when false" do
+      assert_equal ["name_s"], @parser.replace_types(["name_t"], false)
     end
 
-    context "When adding scores" do
-      setup do
-        @solr_data = stub(:results)
-        @solr_data.stubs(:total_hits).returns(1)
-        @solr_data.stubs(:hits).returns([{"id" => 2, "score" => 2.546}])
-        @solr_data.stubs(:max_score).returns 2.1
+    should "include the colon by default" do
+      assert_equal ["name_s:Chunky"], @parser.replace_types(["name_t:Chunky"])
+    end
+  end
+end
 
-        @results = [Array.new]
+context "When adding scores" do
+  setup do
+    @solr_data = stub(:results)
+    @solr_data.stubs(:total_hits).returns(1)
+    @solr_data.stubs(:hits).returns([{"id" => 2, "score" => 2.546}])
+    @solr_data.stubs(:max_score).returns 2.1
 
-        @parser.stubs(:record_id).returns(2)
+    @results = [Array.new]
 
-        @parser.solr_configuration = {:primary_key_field => "id"}
-      end
+    @parser.stubs(:record_id).returns(2)
 
-      should "add the score to the result document" do
-        assert_equal 2.546, @parser.add_scores(@results, @solr_data).first.last.solr_score
-      end
-    end
+    @parser.solr_configuration = {:primary_key_field => "id"}
+  end
+
+  should "add the score to the result document" do
+    assert_equal 2.546, @parser.add_scores(@results, @solr_data).first.last.solr_score
+  end
+end
   end
 end

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: acts_as_solr_reloaded
 version: !ruby/object:Gem::Version 
-  version: 1.4.0
+  prerelease: false
+  segments: 
+  - 1
+  - 5
+  - 0
+  version: 1.5.0
 platform: ruby
 authors: 
 - Diego Carrion
@@ -9,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-02-25 00:00:00 -03:00
+date: 2010-05-19 00:00:00 -03:00
 default_executable: 
 dependencies: []
 
@@ -164,18 +169,20 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: This gem adds full text search capabilities and many other nifty features from Apache Solr to any Rails model.