Removed Ruby warnings.

Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    warden (1.2.2)
+    warden (1.2.3)
       rack (>= 1.0)
 
 GEM

lib/warden/manager.rb

@@ -19,7 +19,7 @@ def initialize(app, options={})
       default_strategies = options.delete(:default_strategies)
 
       @app, @config = app, Warden::Config.new(options)
-      @config.default_strategies *default_strategies if default_strategies
+      @config.default_strategies(*default_strategies) if default_strategies
       yield @config if block_given?
       self
     end
@@ -84,6 +84,11 @@ def serialize_into_session(scope = nil, &block)
       # :api: public
       def serialize_from_session(scope = nil, &block)
         method_name = scope.nil? ? :deserialize : "#{scope}_deserialize"
+
+        if Warden::SessionSerializer.method_defined? method_name
+          Warden::SessionSerializer.send :remove_method, method_name
+        end
+
         Warden::SessionSerializer.send :define_method, method_name, &block
       end
     end

lib/warden/proxy.rb

@@ -69,7 +69,7 @@ def session_serializer
     #
     # :api: public
     def clear_strategies_cache!(*args)
-      scope, opts = _retrieve_scope_and_opts(args)
+      scope, _opts = _retrieve_scope_and_opts(args)
 
       @winning_strategies.delete(scope)
       @strategies[scope].each do |k, v|
@@ -101,7 +101,7 @@ def lock!
     #
     # :api: public
     def authenticate(*args)
-      user, opts = _perform_authentication(*args)
+      user, _opts = _perform_authentication(*args)
       user
     end
 
@@ -290,7 +290,11 @@ def custom_failure!
     # Check to see if the custom failure flag has been set
     # :api: public
     def custom_failure?
-      !!@custom_failure
+      if instance_variable_defined?(:@custom_failure)
+        !!@custom_failure
+      else
+        false
+      end
     end
 
     # Check to see if this is an asset request

spec/warden/authenticated_data_store_spec.rb

@@ -24,7 +24,7 @@
       valid_response
     end
     setup_rack(app).call(@env)
-    @env['rack.session']['warden.user.default.session'].should == {:key => "value"}
+    @env['rack.session']['warden.user.default.session'].should eq({:key => "value"})
     @env['rack.session']['warden.user.foo.session'].should be_nil
   end
 
@@ -34,7 +34,7 @@
       valid_response
     end
     setup_rack(app).call(@env)
-    @env['rack.session']['warden.user.foo.session'].should == {:key => "value"}
+    @env['rack.session']['warden.user.foo.session'].should eq({:key => "value"})
   end
 
   it "should store the data seperately" do
@@ -44,8 +44,8 @@
       valid_response
     end
     setup_rack(app).call(@env)
-    @env['rack.session']['warden.user.default.session'].should == {:key => "value"}
-    @env['rack.session']['warden.user.foo.session'    ].should == {:key => "another value"}
+    @env['rack.session']['warden.user.default.session'].should eq({:key => "value"})
+    @env['rack.session']['warden.user.foo.session'    ].should eq({:key => "another value"})
   end
 
   it "should clear the foo scoped data when foo logs out" do
@@ -56,7 +56,7 @@
       valid_response
     end
     setup_rack(app).call(@env)
-    @env['rack.session']['warden.user.default.session'].should == {:key => "value"}
+    @env['rack.session']['warden.user.default.session'].should eq({:key => "value"})
     @env['rack.session']['warden.user.foo.session'    ].should be_nil
   end
 
@@ -69,7 +69,7 @@
     end
     setup_rack(app).call(@env)
     @env['rack.session']['warden.user.default.session'].should be_nil
-    @env['rack.session']['warden.user.foo.session'    ].should == {:key => "another value"}
+    @env['rack.session']['warden.user.foo.session'    ].should eq({:key => "another value"})
   end
 
   it "should clear out all data when a general logout is performed" do
@@ -96,7 +96,7 @@
     end
     setup_rack(app).call(@env)
     @env['rack.session']['warden.user.default.session'].should be_nil
-    @env['rack.session']['warden.user.foo.session'    ].should == {:key => "another value"}
+    @env['rack.session']['warden.user.foo.session'    ].should eq({:key => "another value"})
     @env['rack.session']['warden.user.bar.session'    ].should be_nil
   end
 

spec/warden/config_spec.rb

@@ -9,19 +9,19 @@
 
   it "should behave like a hash" do
     @config[:foo] = :bar
-    @config[:foo].should == :bar
+    @config[:foo].should be(:bar)
   end
 
   it "should provide hash accessors" do
     @config.failure_app = :foo
-    @config[:failure_app].should == :foo
+    @config[:failure_app].should be(:foo)
     @config[:failure_app] = :bar
-    @config.failure_app.should == :bar
+    @config.failure_app.should be(:bar)
   end
 
   it "should allow to read and set default strategies" do
     @config.default_strategies :foo, :bar
-    @config.default_strategies.should == [:foo, :bar]
+    @config.default_strategies.should eq([:foo, :bar])
   end
 
   it "should allow to silence missing strategies" do
@@ -30,19 +30,19 @@
   end
 
   it "should set the default_scope" do
-    @config.default_scope.should == :default
+    @config.default_scope.should be(:default)
     @config.default_scope = :foo
-    @config.default_scope.should == :foo
+    @config.default_scope.should be(:foo)
   end
 
   it "should merge given options on initialization" do
-    Warden::Config.new(:foo => :bar)[:foo].should == :bar
+    Warden::Config.new(:foo => :bar)[:foo].should be(:bar)
   end
 
   it "should setup defaults with the scope_defaults method" do
     c = Warden::Config.new
     c.scope_defaults :foo, :strategies => [:foo, :bar], :store => false
-    c.default_strategies(:scope => :foo).should == [:foo, :bar]
-    c.scope_defaults(:foo).should == {:store => false}
+    c.default_strategies(:scope => :foo).should eq([:foo, :bar])
+    c.scope_defaults(:foo).should eq({:store => false})
   end
 end

spec/warden/errors_spec.rb

@@ -8,23 +8,23 @@
   end
 
   it "should report that it is empty on first creation" do
-    @errors.empty?.should == true
+    @errors.empty?.should be_true
   end
 
   it "should continue to report that it is empty even after being checked" do
     @errors.on(:foo)
-    @errors.empty?.should == true
+    @errors.empty?.should be_true
   end
 
   it "should add an error" do
     @errors.add(:login, "Login or password incorrect")
-    @errors[:login].should == ["Login or password incorrect"]
+    @errors[:login].should eq(["Login or password incorrect"])
   end
 
   it "should allow many errors to be added to the same field" do
     @errors.add(:login, "bad 1")
     @errors.add(:login, "bad 2")
-    @errors.on(:login).should == ["bad 1", "bad 2"]
+    @errors.on(:login).should eq(["bad 1", "bad 2"])
   end
 
   it "should give the full messages for an error" do
@@ -37,7 +37,7 @@
 
   it "should return the error for a specific field / label" do
     @errors.add(:login, "wrong")
-    @errors.on(:login).should == ["wrong"]
+    @errors.on(:login).should eq(["wrong"])
   end
 
   it "should return nil for a specific field if it's not been set" do

spec/warden/hooks_spec.rb

@@ -41,8 +41,8 @@
       env = env_with_params
       setup_rack(app).call(env)
       env['warden'].user.should be_nil
-      env['warden.spec.hook.foo'].should == "run foo"
-      env['warden.spec.hook.bar'].should == "run bar"
+      env['warden.spec.hook.foo'].should eq("run foo")
+      env['warden.spec.hook.bar'].should eq("run bar")
     end
 
     it "should not run the event specified with except" do
@@ -76,22 +76,22 @@
       end
       env = env_with_params
       setup_rack(app).call(env)
-      env['warden.spec.order'].should == [1,2,3]
+      env['warden.spec.order'].should eq([1,2,3])
     end
 
     context "after_authentication" do
       it "should be a wrapper to after_set_user behavior" do
         RAM.after_authentication{|u,a,o| a.env['warden.spec.hook.baz'] = "run baz"}
         RAM.after_authentication{|u,a,o| a.env['warden.spec.hook.paz'] = "run paz"}
-        RAM.after_authentication{|u,a,o| o[:event].should == :authentication }
+        RAM.after_authentication{|u,a,o| o[:event].should be(:authentication) }
         app = lambda do |e|
           e['warden'].authenticate(:pass)
           valid_response
         end
         env = env_with_params
         setup_rack(app).call(env)
-        env['warden.spec.hook.baz'].should == 'run baz'
-        env['warden.spec.hook.paz'].should == 'run paz'
+        env['warden.spec.hook.baz'].should eq('run baz')
+        env['warden.spec.hook.paz'].should eq('run paz')
       end
 
       it "should not be invoked on default after_set_user scenario" do
@@ -115,7 +115,7 @@
         end
         env = env_with_params
         setup_rack(app).call(env)
-        env['warden.spec.order'].should == [1,2,3]
+        env['warden.spec.order'].should eq([1,2,3])
       end
 
       it "should allow me to log out a user in an after_set_user block" do
@@ -135,13 +135,13 @@
       it "should be a wrapper to after_set_user behavior" do
         RAM.after_fetch{|u,a,o| a.env['warden.spec.hook.baz'] = "run baz"}
         RAM.after_fetch{|u,a,o| a.env['warden.spec.hook.paz'] = "run paz"}
-        RAM.after_fetch{|u,a,o| o[:event].should == :fetch }
+        RAM.after_fetch{|u,a,o| o[:event].should be(:fetch) }
         env = env_with_params
         setup_rack(lambda { |e| valid_response }).call(env)
         env['rack.session']['warden.user.default.key'] = "Foo"
-        env['warden'].user.should == "Foo"
-        env['warden.spec.hook.baz'].should == 'run baz'
-        env['warden.spec.hook.paz'].should == 'run paz'
+        env['warden'].user.should eq("Foo")
+        env['warden.spec.hook.baz'].should eq('run baz')
+        env['warden.spec.hook.paz'].should eq('run paz')
       end
 
       it "should not be invoked on default after_set_user scenario" do
@@ -174,7 +174,7 @@
         end
         env = env_with_params
         setup_rack(app).call(env)
-        env['warden.spec.order'].should == [1,2,3]
+        env['warden.spec.order'].should eq([1,2,3])
       end
     end
   end
@@ -195,7 +195,7 @@
       env = env_with_params
       setup_rack(lambda { |e| valid_response }).call(env)
       env['rack.session']['warden.user.default.key'] = "Foo"
-      env['warden'].user.should == "Foo"
+      env['warden'].user.should eq("Foo")
     end
 
     it "should be called if fetched user is nil" do
@@ -204,7 +204,7 @@
       env = env_with_params
       setup_rack(lambda { |e| valid_response }).call(env)
       env['warden'].user.should be_nil
-      calls.should == 1
+      calls.should be(1)
     end
   end
 
@@ -235,8 +235,8 @@
       app = lambda{|e| e['warden'].authenticate!(:failz); valid_response}
       env = env_with_params
       setup_rack(app).call(env)
-      env['warden.spec.before_failure.foo'].should == "foo"
-      env['warden.spec.before_failure.bar'].should  == "bar"
+      env['warden.spec.before_failure.foo'].should eq("foo")
+      env['warden.spec.before_failure.bar'].should eq("bar")
     end
 
     it "should run filters in the given order" do
@@ -250,7 +250,7 @@
       end
       env = env_with_params
       setup_rack(app).call(env)
-      env['warden.spec.order'].should == [1,2,3]
+      env['warden.spec.order'].should eq([1,2,3])
     end
   end
 
@@ -282,8 +282,8 @@
       env = env_with_params
       setup_rack(app).call(env)
       env['warden'].logout
-      env['warden.spec.hook.lorem'].should == 'run lorem'
-      env['warden.spec.hook.ipsum'].should == 'run ipsum'
+      env['warden.spec.hook.lorem'].should eq('run lorem')
+      env['warden.spec.hook.ipsum'].should eq('run ipsum')
     end
 
     it "should run before_logout hook for a specified scope" do
@@ -301,12 +301,12 @@
       setup_rack(app).call(env)
 
       env['warden'].logout(:scope1)
-      env['warden.spec.hook.a'].should == [:scope1]
-      env['warden.spec.hook.b'].should == []
+      env['warden.spec.hook.a'].should eq([:scope1])
+      env['warden.spec.hook.b'].should eq([])
 
       env['warden'].logout(:scope2)
-      env['warden.spec.hook.a'].should == [:scope1]
-      env['warden.spec.hook.b'].should == [:scope2]
+      env['warden.spec.hook.a'].should eq([:scope1])
+      env['warden.spec.hook.b'].should eq([:scope2])
     end
 
     it "should run filters in the given order" do
@@ -321,7 +321,7 @@
       end
       env = env_with_params
       setup_rack(app).call(env)
-      env['warden.spec.order'].should == [1,2,3]
+      env['warden.spec.order'].should eq([1,2,3])
     end
   end
 
@@ -354,8 +354,8 @@
       app = lambda{|e| valid_response}
       env = env_with_params
       setup_rack(app).call(env)
-      env['warden.spec.on_request.foo'].should == "foo"
-      env['warden.spec.on_request.bar'].should  == "bar"
+      env['warden.spec.on_request.foo'].should eq("foo")
+      env['warden.spec.on_request.bar'].should  eq("bar")
     end
 
     it "should run filters in the given order" do
@@ -367,7 +367,7 @@
       end
       env = Rack::MockRequest.env_for("/", "warden.spec.order" => [])
       setup_rack(app).call(env)
-      env['warden.spec.order'].should == [1,2,3]
+      env['warden.spec.order'].should eq([1,2,3])
     end
   end
 end