vines 0.4.3 → 0.4.4

data/Rakefile

@@ -41,7 +41,7 @@ is mandatory on all client and server connections."
   s.add_dependency "http_parser.rb", "~> 0.5.3"
   s.add_dependency "mongo", "~> 1.5.2"
   s.add_dependency "bson_ext", "~> 1.5.2"
-  s.add_dependency "net-ldap", "~> 0.2.2"
+  s.add_dependency "net-ldap", "~> 0.3.1"
   s.add_dependency "nokogiri", "~> 1.4.7"
 
   s.add_development_dependency "minitest", "~> 2.12.1"

data/lib/vines/storage.rb

@@ -35,18 +35,10 @@ module Vines
     # enabled library like em-http-request or em-redis) don't need any special
     # consideration and must not use this method.
     def self.defer(method)
-      old = "_deferred_#{method}"
-      alias_method old, method
+      old = instance_method(method)
       define_method method do |*args|
         fiber = Fiber.current
-        op = proc do
-          begin
-            method(old).call(*args)
-          rescue => e
-            log.error("Thread pool operation failed: #{e.message}")
-            nil
-          end
-        end
+        op = operation { old.bind(self).call(*args) }
         cb = proc {|result| fiber.resume(result) }
         EM.defer(op, cb)
         Fiber.yield
@@ -64,10 +56,9 @@ module Vines
     # end
     # wrap_ldap :authenticate
     def self.wrap_ldap(method)
-      old = "_ldap_#{method}"
-      alias_method old, method
+      old = instance_method(method)
       define_method method do |*args|
-        ldap? ? authenticate_with_ldap(*args) : method(old).call(*args)
+        ldap? ? authenticate_with_ldap(*args) : old.bind(self).call(*args)
       end
     end
 
@@ -89,24 +80,23 @@ module Vines
     # user = storage.find_user('alice@wonderland.lit')
     # puts user.nil?
     def self.fiber(method)
-      old = "_fiber_#{method}"
-      alias_method old, method
+      old = instance_method(method)
       define_method method do |*args|
         fiber, yielding = Fiber.current, true
-        method(old).call(*args) do |user|
+        old.bind(self).call(*args) do |user|
           fiber.resume(user) rescue yielding = false
         end
         Fiber.yield if yielding
       end
     end
 
-    # Return true if users are authenticated against an LDAP directory.
+    # Return +true+ if users are authenticated against an LDAP directory.
     def ldap?
       !!ldap
     end
 
-    # Validate the username and password pair and return a Vines::User object
-    # on success. Return nil on failure.
+    # Validate the username and password pair and return a +Vines::User+ object
+    # on success. Return +nil+ on failure.
     #
     # For example:
     # user = storage.authenticate('alice@wonderland.lit', 'secr3t')
@@ -122,7 +112,7 @@ module Vines
     end
     wrap_ldap :authenticate
 
-    # Return the Vines::User associated with the JID. Return nil if the user
+    # Return the +Vines::User+ associated with the JID. Return +nil+ if the user
     # could not be found. JID may be +nil+, a +String+, or a +Vines::JID+
     # object. It may be a bare JID or a full JID. Implementations of this method
     # must convert the JID to a bare JID before searching for the user in the
@@ -134,7 +124,7 @@ module Vines
       raise 'subclass must implement'
     end
 
-    # Persist the Vines::User object to the database and return when the save
+    # Persist the +Vines::User+ object to the database and return when the save
     # is complete.
     #
     # alice = Vines::User.new(:jid => 'alice@wonderland.lit')
@@ -206,28 +196,33 @@ module Vines
       args.flatten.any? {|arg| (arg || '').strip.empty? }
     end
 
-    # Return a Vines::User object if we are able to bind to the LDAP server
-    # using the username and password. Return nil if authentication failed. If
-    # authentication succeeds, but the user is not yet stored in our database,
-    # save the user to the database.
-    def authenticate_with_ldap(username, password, &block)
-      if empty?(username, password)
-        block.call; return
-      end
-
-      op = proc do
+    # Return a +proc+ suitable for running on the +EM.defer+ thread pool that traps
+    # and logs any errors thrown by the provided block.
+    def operation
+      proc do
         begin
-          ldap.authenticate(username, password)
+          yield
         rescue => e
-          log.error("LDAP authentication failed: #{e.message}")
+          log.error("Thread pool operation failed: #{e.message}")
           nil
         end
       end
+    end
+
+    # Return a +Vines::User+ object if we are able to bind to the LDAP server
+    # using the username and password. Return +nil+ if authentication failed. If
+    # authentication succeeds, but the user is not yet stored in our database,
+    # save the user to the database.
+    def authenticate_with_ldap(username, password, &block)
+      op = operation { ldap.authenticate(username, password) }
       cb = proc {|user| save_ldap_user(user, &block) }
       EM.defer(op, cb)
     end
     fiber :authenticate_with_ldap
 
+    # Save missing users to the storage database after they're authenticated with
+    # LDAP. This allows admins to define users once in LDAP and have them sync
+    # to the chat database the first time they successfully sign in.
     def save_ldap_user(user, &block)
       Fiber.new do
         if user.nil?

data/lib/vines/storage/ldap.rb

@@ -17,7 +17,7 @@ module Vines
       end
 
       def initialize(host='localhost', port=636, &block)
-        @config = {:host => host, :port => port}
+        @config = {host: host, port: port}
         instance_eval(&block)
         @@required.each {|key| raise "Must provide #{key}" if @config[key].nil? }
       end
@@ -26,17 +26,18 @@ module Vines
       # those credentials. If the bind succeeds, the user's attributes are
       # retrieved.
       def authenticate(username, password)
+        username = JID.new(username).to_s rescue nil
         return if [username, password].any? {|arg| (arg || '').strip.empty? }
 
         ldap = connect(@config[:dn], @config[:password])
         entries = ldap.search(
-          :attributes => [@config[:name_attr], 'mail'],
-          :filter => filter(username))
+          attributes: [@config[:name_attr], 'mail'],
+          filter: filter(username))
         return unless entries && entries.size == 1
 
         user = if connect(entries.first.dn, password).bind
           name = entries.first[@config[:name_attr]].first
-          User.new(:jid => username, :name => name.to_s, :roster => [])
+          User.new(jid: username, name: name.to_s, roster: [])
         end
         user
       end

data/lib/vines/storage/sql.rb

@@ -23,11 +23,10 @@ module Vines
       # ActiveRecord uses blocking IO.
       def self.with_connection(method, args={})
         deferrable = args.key?(:defer) ? args[:defer] : true
-        old = "_with_connection_#{method}"
-        alias_method old, method
+        old = instance_method(method)
         define_method method do |*args|
           ActiveRecord::Base.connection_pool.with_connection do
-            method(old).call(*args)
+            old.bind(self).call(*args)
           end
         end
         defer(method) if deferrable

data/lib/vines/version.rb

@@ -1,5 +1,5 @@
 # encoding: UTF-8
 
 module Vines
-  VERSION = '0.4.3'
+  VERSION = '0.4.4'
 end

data/test/storage/ldap_test.rb

@@ -3,20 +3,31 @@
 require 'vines'
 require 'minitest/autorun'
 
-class LdapTest < MiniTest::Unit::TestCase
+describe Vines::Storage::Ldap do
   ALICE_DN = 'uid=alice@wondlerand.lit,ou=People,dc=wonderland,dc=lit'
   CONTEXT = {}
 
-  def setup
-  end
-
-  def teardown
+  after do
     CONTEXT.clear
   end
 
-  def test_missing_host_and_port
-    assert_raises(RuntimeError) do
-      Vines::Storage::Ldap.new(nil, nil) do
+  describe '#initialize' do
+    it 'raises with missing host and port' do
+      assert_raises(RuntimeError) do
+        Vines::Storage::Ldap.new(nil, nil) do
+          tls true
+          dn 'cn=Directory Manager'
+          password 'secr3t'
+          basedn 'dc=wonderland,dc=lit'
+          object_class 'person'
+          user_attr 'uid'
+          name_attr 'cn'
+        end
+      end
+    end
+
+    it 'does not raise when using default host and port' do
+      Vines::Storage::Ldap.new do
         tls true
         dn 'cn=Directory Manager'
         password 'secr3t'
@@ -26,162 +37,153 @@ class LdapTest < MiniTest::Unit::TestCase
         name_attr 'cn'
       end
     end
-  end
 
-  def test_default_host_and_port_raises_no_errors
-    Vines::Storage::Ldap.new do
-      tls true
-      dn 'cn=Directory Manager'
-      password 'secr3t'
-      basedn 'dc=wonderland,dc=lit'
-      object_class 'person'
-      user_attr 'uid'
-      name_attr 'cn'
+    it 'does not raise when given a host and port' do
+      Vines::Storage::Ldap.new('0.0.0.1', 42) do
+        tls true
+        dn 'cn=Directory Manager'
+        password 'secr3t'
+        basedn 'dc=wonderland,dc=lit'
+        object_class 'person'
+        user_attr 'uid'
+        name_attr 'cn'
+      end
     end
-  end
 
-  def test_configured_host_and_port_raises_no_errors
-    Vines::Storage::Ldap.new('0.0.0.1', 42) do
-      tls true
-      dn 'cn=Directory Manager'
-      password 'secr3t'
-      basedn 'dc=wonderland,dc=lit'
-      object_class 'person'
-      user_attr 'uid'
-      name_attr 'cn'
+    it 'raises when given no parameters' do
+      assert_raises(RuntimeError) do
+        Vines::Storage::Ldap.new {}
+      end
     end
-  end
 
-  def test_missing_parameters
-    assert_raises(RuntimeError) do
-      Vines::Storage::Ldap.new {}
+    it 'raises when given blank parameters' do
+      assert_raises(RuntimeError) do
+        Vines::Storage::Ldap.new do
+          tls
+          dn
+          password
+          basedn
+          object_class
+          user_attr
+          name_attr
+        end
+      end
     end
-  end
 
-  def test_blank_parameters
-    assert_raises(RuntimeError) do
+    it 'handles boolean false values without raising' do
       Vines::Storage::Ldap.new do
-        tls
-        dn
-        password
-        basedn
-        object_class
-        user_attr
-        name_attr
+        tls false
+        dn 'cn=Directory Manager'
+        password 'secr3t'
+        basedn 'dc=wonderland,dc=lit'
+        object_class 'person'
+        user_attr 'uid'
+        name_attr 'cn'
       end
     end
   end
 
-  # Make sure we properly handle boolean false values.
-  def test_false_tls_raises_no_errors
-    Vines::Storage::Ldap.new do
-      tls false
-      dn 'cn=Directory Manager'
-      password 'secr3t'
-      basedn 'dc=wonderland,dc=lit'
-      object_class 'person'
-      user_attr 'uid'
-      name_attr 'cn'
+  describe '#authenticate' do
+    it 'fails with invalid credentials' do
+      ldap = connect
+      assert_nil ldap.authenticate(nil, nil)
+      assert_nil ldap.authenticate('', '')
+      assert_nil ldap.authenticate('alice@wonderland.lit', ' ')
+      assert_nil ldap.authenticate('bogus"jid@wonderland.lit', 'password')
+      assert_nil ldap.authenticate(Vines::JID.new('alice@wonderland.lit'), '')
     end
-  end
 
-  def test_authenticate_with_missing_credentials
-    ldap = connect
-    assert_nil ldap.authenticate(nil, nil)
-    assert_nil ldap.authenticate('', '')
-    assert_nil ldap.authenticate('user', ' ')
-  end
-
-  def test_authenticate_user_not_found
-    CONTEXT.merge!({
-      :mock_ldap => MiniTest::Mock.new,
-      :connect_calls => 0
-    })
-    ldap = connect
-    def ldap.connect(dn, password)
-      CONTEXT[:connect_calls] += 1
-      raise unless 'cn=Directory Manager' == dn
-      raise unless 'secr3t' == password
-
-      clas = Net::LDAP::Filter.eq('objectClass', 'person')
-      uid = Net::LDAP::Filter.eq('uid', 'alice@wonderland.lit')
-
-      mock = CONTEXT[:mock_ldap]
-      mock.expect(:search, [], [{:attributes => ['cn', 'mail'], :filter => clas & uid}])
+    it 'fails when user not found' do
+      CONTEXT.merge!({
+        :mock_ldap => MiniTest::Mock.new,
+        :connect_calls => 0
+      })
+      ldap = connect
+      def ldap.connect(dn, password)
+        CONTEXT[:connect_calls] += 1
+        raise unless 'cn=Directory Manager' == dn
+        raise unless 'secr3t' == password
+
+        clas = Net::LDAP::Filter.eq('objectClass', 'person')
+        uid = Net::LDAP::Filter.eq('uid', 'alice@wonderland.lit')
+
+        mock = CONTEXT[:mock_ldap]
+        mock.expect(:search, [], [{:attributes => ['cn', 'mail'], :filter => clas & uid}])
+      end
+      assert_nil ldap.authenticate('alice@wonderland.lit', 'passw0rd')
+      assert CONTEXT[:mock_ldap]
+      assert_equal 1, CONTEXT[:connect_calls]
     end
-    assert_nil ldap.authenticate('alice@wonderland.lit', 'passw0rd')
-    assert CONTEXT[:mock_ldap]
-    assert_equal 1, CONTEXT[:connect_calls]
-  end
 
-  def test_authenticate_user_fails_bind
-    CONTEXT.merge!({
-      :credentials => [
-        {:dn => 'cn=Directory Manager', :password => 'secr3t'},
-        {:dn => ALICE_DN, :password => 'passw0rd'}
-      ],
-      :mock_ldap => MiniTest::Mock.new,
-      :mock_entry => MiniTest::Mock.new,
-      :connect_calls => 0
-    })
-    ldap = connect
-    def ldap.connect(dn, password)
-      credentials = CONTEXT[:credentials][CONTEXT[:connect_calls]]
-      CONTEXT[:connect_calls] += 1
-      raise unless credentials[:dn] == dn && credentials[:password] == password
-
-      clas = Net::LDAP::Filter.eq('objectClass', 'person')
-      uid = Net::LDAP::Filter.eq('uid', 'alice@wonderland.lit')
-
-      entry = CONTEXT[:mock_entry]
-      entry.expect(:dn, ALICE_DN)
-
-      mock = CONTEXT[:mock_ldap]
-      mock.expect(:search, [entry], [{:attributes => ['cn', 'mail'], :filter => clas & uid}])
-      mock.expect(:bind, false)
+    it 'fails when user cannot bind' do
+      CONTEXT.merge!({
+        :credentials => [
+          {:dn => 'cn=Directory Manager', :password => 'secr3t'},
+          {:dn => ALICE_DN, :password => 'passw0rd'}
+        ],
+        :mock_ldap => MiniTest::Mock.new,
+        :mock_entry => MiniTest::Mock.new,
+        :connect_calls => 0
+      })
+      ldap = connect
+      def ldap.connect(dn, password)
+        credentials = CONTEXT[:credentials][CONTEXT[:connect_calls]]
+        CONTEXT[:connect_calls] += 1
+        raise unless credentials[:dn] == dn && credentials[:password] == password
+
+        clas = Net::LDAP::Filter.eq('objectClass', 'person')
+        uid = Net::LDAP::Filter.eq('uid', 'alice@wonderland.lit')
+
+        entry = CONTEXT[:mock_entry]
+        entry.expect(:dn, ALICE_DN)
+
+        mock = CONTEXT[:mock_ldap]
+        mock.expect(:search, [entry], [{:attributes => ['cn', 'mail'], :filter => clas & uid}])
+        mock.expect(:bind, false)
+      end
+      assert_nil ldap.authenticate('alice@wonderland.lit', 'passw0rd')
+      assert_equal 2, CONTEXT[:connect_calls]
+      assert CONTEXT[:mock_entry].verify
+      assert CONTEXT[:mock_ldap].verify
     end
-    assert_nil ldap.authenticate('alice@wonderland.lit', 'passw0rd')
-    assert_equal 2, CONTEXT[:connect_calls]
-    assert CONTEXT[:mock_entry].verify
-    assert CONTEXT[:mock_ldap].verify
-  end
 
-  def test_authenticate_success
-    CONTEXT.merge!({
-      :credentials => [
-        {:dn => 'cn=Directory Manager', :password => 'secr3t'},
-        {:dn => ALICE_DN, :password => 'passw0rd'}
-      ],
-      :mock_ldap => MiniTest::Mock.new,
-      :mock_entry => MiniTest::Mock.new,
-      :connect_calls => 0
-    })
-    ldap = connect
-    def ldap.connect(dn, password)
-      credentials = CONTEXT[:credentials][CONTEXT[:connect_calls]]
-      CONTEXT[:connect_calls] += 1
-      raise unless credentials[:dn] == dn && credentials[:password] == password
-
-      clas = Net::LDAP::Filter.eq('objectClass', 'person')
-      uid = Net::LDAP::Filter.eq('uid', 'alice@wonderland.lit')
-
-      entry = CONTEXT[:mock_entry]
-      entry.expect(:dn, ALICE_DN)
-      entry.expect(:[], ['Alice Liddell'], ['cn'])
-
-      mock = CONTEXT[:mock_ldap]
-      mock.expect(:search, [entry], [{:attributes => ['cn', 'mail'], :filter => clas & uid}])
-      mock.expect(:bind, true)
+    it 'authenticates successfully with proper credentials' do
+      CONTEXT.merge!({
+        :credentials => [
+          {:dn => 'cn=Directory Manager', :password => 'secr3t'},
+          {:dn => ALICE_DN, :password => 'passw0rd'}
+        ],
+        :mock_ldap => MiniTest::Mock.new,
+        :mock_entry => MiniTest::Mock.new,
+        :connect_calls => 0
+      })
+      ldap = connect
+      def ldap.connect(dn, password)
+        credentials = CONTEXT[:credentials][CONTEXT[:connect_calls]]
+        CONTEXT[:connect_calls] += 1
+        raise unless credentials[:dn] == dn && credentials[:password] == password
+
+        clas = Net::LDAP::Filter.eq('objectClass', 'person')
+        uid = Net::LDAP::Filter.eq('uid', 'alice@wonderland.lit')
+
+        entry = CONTEXT[:mock_entry]
+        entry.expect(:dn, ALICE_DN)
+        entry.expect(:[], ['Alice Liddell'], ['cn'])
+
+        mock = CONTEXT[:mock_ldap]
+        mock.expect(:search, [entry], [{:attributes => ['cn', 'mail'], :filter => clas & uid}])
+        mock.expect(:bind, true)
+      end
+      user = ldap.authenticate('alice@wonderland.lit', 'passw0rd')
+      refute_nil user
+      assert_equal 'alice@wonderland.lit', user.jid.to_s
+      assert_equal 'Alice Liddell', user.name
+      assert_equal [], user.roster
+
+      assert_equal 2, CONTEXT[:connect_calls]
+      assert CONTEXT[:mock_entry].verify
+      assert CONTEXT[:mock_ldap].verify
     end
-    user = ldap.authenticate('alice@wonderland.lit', 'passw0rd')
-    refute_nil user
-    assert_equal 'alice@wonderland.lit', user.jid.to_s
-    assert_equal 'Alice Liddell', user.name
-    assert_equal [], user.roster
-
-    assert_equal 2, CONTEXT[:connect_calls]
-    assert CONTEXT[:mock_entry].verify
-    assert CONTEXT[:mock_ldap].verify
   end
 
   private

data/test/storage/mock_redis.rb

@@ -6,10 +6,9 @@ class MockRedis
 
   # Mimic em-hiredis behavior.
   def self.defer(method)
-    old = "_deferred_#{method}"
-    alias_method old, method
+    old = instance_method(method)
     define_method method do |*args, &block|
-      result = method(old).call(*args)
+      result = old.bind(self).call(*args)
       deferred = EM::DefaultDeferrable.new
       deferred.callback(&block) if block
       EM.next_tick { deferred.succeed(result) }

data/test/storage_test.rb

@@ -4,7 +4,7 @@ require 'storage_tests'
 require 'vines'
 require 'minitest/autorun'
 
-class StorageTest < MiniTest::Unit::TestCase
+describe Vines::Storage do
   ALICE = 'alice@wonderland.lit'.freeze
 
   class MockLdapStorage < Vines::Storage
@@ -39,58 +39,48 @@ class StorageTest < MiniTest::Unit::TestCase
     end
   end
 
-  def test_authenticate_with_ldap_missing_password
-    StorageTests::EMLoop.new do
-      storage = MockLdapStorage.new
-      user = storage.authenticate(ALICE, '')
-      assert_nil user
-      assert_equal 0, storage.authenticate_calls
-      assert_equal 0, storage.find_user_calls
-      assert_equal 0, storage.save_user_calls
-      assert_nil storage.ldap.auth # ldap never called
+  describe '#authenticate_with_ldap' do
+    it 'fails when given a bad password' do
+      StorageTests::EMLoop.new do
+        storage = MockLdapStorage.new
+        storage.ldap.user = nil
+        user = storage.authenticate(ALICE, 'bogus')
+        assert_nil user
+        assert_equal 0, storage.authenticate_calls
+        assert_equal 0, storage.find_user_calls
+        assert_equal 0, storage.save_user_calls
+        assert_equal [ALICE, 'bogus'], storage.ldap.auth.first
+      end
     end
-  end
 
-  def test_authenticate_with_ldap_bad_password
-    StorageTests::EMLoop.new do
-      storage = MockLdapStorage.new
-      storage.ldap.user = nil
-      user = storage.authenticate(ALICE, 'bogus')
-      assert_nil user
-      assert_equal 0, storage.authenticate_calls
-      assert_equal 0, storage.find_user_calls
-      assert_equal 0, storage.save_user_calls
-      assert_equal [ALICE, 'bogus'], storage.ldap.auth.first
+    it 'succeeds when user exists in database' do
+      StorageTests::EMLoop.new do
+        alice = Vines::User.new(:jid => ALICE)
+        storage = MockLdapStorage.new(alice)
+        storage.ldap.user = alice
+        user = storage.authenticate(ALICE, 'secr3t')
+        refute_nil user
+        assert_equal ALICE, user.jid.to_s
+        assert_equal 0, storage.authenticate_calls
+        assert_equal 1, storage.find_user_calls
+        assert_equal 0, storage.save_user_calls
+        assert_equal [ALICE, 'secr3t'], storage.ldap.auth.first
+      end
     end
-  end
-
-  def test_authenticate_with_ldap_user_exists_in_database
-    StorageTests::EMLoop.new do
-      alice = Vines::User.new(:jid => ALICE)
-      storage = MockLdapStorage.new(alice)
-      storage.ldap.user = alice
-      user = storage.authenticate(ALICE, 'secr3t')
-      refute_nil user
-      assert_equal ALICE, user.jid.to_s
-      assert_equal 0, storage.authenticate_calls
-      assert_equal 1, storage.find_user_calls
-      assert_equal 0, storage.save_user_calls
-      assert_equal [ALICE, 'secr3t'], storage.ldap.auth.first
-    end
-  end
 
-  def test_authenticate_with_ldap_save_user_to_database
-    StorageTests::EMLoop.new do
-      alice = Vines::User.new(:jid => ALICE)
-      storage = MockLdapStorage.new
-      storage.ldap.user = alice
-      user = storage.authenticate(ALICE, 'secr3t')
-      refute_nil user
-      assert_equal ALICE, user.jid.to_s
-      assert_equal 0, storage.authenticate_calls
-      assert_equal 1, storage.find_user_calls
-      assert_equal 1, storage.save_user_calls
-      assert_equal [ALICE, 'secr3t'], storage.ldap.auth.first
+    it 'succeeds and saves user to the database' do
+      StorageTests::EMLoop.new do
+        alice = Vines::User.new(:jid => ALICE)
+        storage = MockLdapStorage.new
+        storage.ldap.user = alice
+        user = storage.authenticate(ALICE, 'secr3t')
+        refute_nil user
+        assert_equal ALICE, user.jid.to_s
+        assert_equal 0, storage.authenticate_calls
+        assert_equal 1, storage.find_user_calls
+        assert_equal 1, storage.save_user_calls
+        assert_equal [ALICE, 'secr3t'], storage.ldap.auth.first
+      end
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vines
 version: !ruby/object:Gem::Version
-  version: 0.4.3
+  version: 0.4.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-04-16 00:00:00.000000000Z
+date: 2012-04-19 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
-  requirement: &70110878851480 !ruby/object:Gem::Requirement
+  requirement: &70188360341400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: 3.2.3
   type: :runtime
   prerelease: false
-  version_requirements: *70110878851480
+  version_requirements: *70188360341400
 - !ruby/object:Gem::Dependency
   name: bcrypt-ruby
-  requirement: &70110878850760 !ruby/object:Gem::Requirement
+  requirement: &70188360340640 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: 3.0.1
   type: :runtime
   prerelease: false
-  version_requirements: *70110878850760
+  version_requirements: *70188360340640
 - !ruby/object:Gem::Dependency
   name: em-http-request
-  requirement: &70110878848940 !ruby/object:Gem::Requirement
+  requirement: &70188360339620 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,10 +43,10 @@ dependencies:
         version: 1.0.2
   type: :runtime
   prerelease: false
-  version_requirements: *70110878848940
+  version_requirements: *70188360339620
 - !ruby/object:Gem::Dependency
   name: em-hiredis
-  requirement: &70110878848100 !ruby/object:Gem::Requirement
+  requirement: &70188360334900 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -54,10 +54,10 @@ dependencies:
         version: 0.1.1
   type: :runtime
   prerelease: false
-  version_requirements: *70110878848100
+  version_requirements: *70188360334900
 - !ruby/object:Gem::Dependency
   name: eventmachine
-  requirement: &70110878847340 !ruby/object:Gem::Requirement
+  requirement: &70188360333880 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -65,10 +65,10 @@ dependencies:
         version: 0.12.10
   type: :runtime
   prerelease: false
-  version_requirements: *70110878847340
+  version_requirements: *70188360333880
 - !ruby/object:Gem::Dependency
   name: http_parser.rb
-  requirement: &70110878846460 !ruby/object:Gem::Requirement
+  requirement: &70188360332740 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -76,10 +76,10 @@ dependencies:
         version: 0.5.3
   type: :runtime
   prerelease: false
-  version_requirements: *70110878846460
+  version_requirements: *70188360332740
 - !ruby/object:Gem::Dependency
   name: mongo
-  requirement: &70110878845140 !ruby/object:Gem::Requirement
+  requirement: &70188360331500 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -87,10 +87,10 @@ dependencies:
         version: 1.5.2
   type: :runtime
   prerelease: false
-  version_requirements: *70110878845140
+  version_requirements: *70188360331500
 - !ruby/object:Gem::Dependency
   name: bson_ext
-  requirement: &70110878844340 !ruby/object:Gem::Requirement
+  requirement: &70188360330140 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -98,21 +98,21 @@ dependencies:
         version: 1.5.2
   type: :runtime
   prerelease: false
-  version_requirements: *70110878844340
+  version_requirements: *70188360330140
 - !ruby/object:Gem::Dependency
   name: net-ldap
-  requirement: &70110878843460 !ruby/object:Gem::Requirement
+  requirement: &70188360329300 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 0.2.2
+        version: 0.3.1
   type: :runtime
   prerelease: false
-  version_requirements: *70110878843460
+  version_requirements: *70188360329300
 - !ruby/object:Gem::Dependency
   name: nokogiri
-  requirement: &70110878842540 !ruby/object:Gem::Requirement
+  requirement: &70188360328540 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -120,10 +120,10 @@ dependencies:
         version: 1.4.7
   type: :runtime
   prerelease: false
-  version_requirements: *70110878842540
+  version_requirements: *70188360328540
 - !ruby/object:Gem::Dependency
   name: minitest
-  requirement: &70110878841520 !ruby/object:Gem::Requirement
+  requirement: &70188360327640 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -131,10 +131,10 @@ dependencies:
         version: 2.12.1
   type: :development
   prerelease: false
-  version_requirements: *70110878841520
+  version_requirements: *70188360327640
 - !ruby/object:Gem::Dependency
   name: coffee-script
-  requirement: &70110878840300 !ruby/object:Gem::Requirement
+  requirement: &70188360326740 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -142,10 +142,10 @@ dependencies:
         version: 2.2.0
   type: :development
   prerelease: false
-  version_requirements: *70110878840300
+  version_requirements: *70188360326740
 - !ruby/object:Gem::Dependency
   name: coffee-script-source
-  requirement: &70110878839260 !ruby/object:Gem::Requirement
+  requirement: &70188360326200 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -153,10 +153,10 @@ dependencies:
         version: 1.2.0
   type: :development
   prerelease: false
-  version_requirements: *70110878839260
+  version_requirements: *70188360326200
 - !ruby/object:Gem::Dependency
   name: uglifier
-  requirement: &70110878838580 !ruby/object:Gem::Requirement
+  requirement: &70188360325340 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -164,10 +164,10 @@ dependencies:
         version: 1.2.4
   type: :development
   prerelease: false
-  version_requirements: *70110878838580
+  version_requirements: *70188360325340
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70110878837720 !ruby/object:Gem::Requirement
+  requirement: &70188360324400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -175,10 +175,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70110878837720
+  version_requirements: *70188360324400
 - !ruby/object:Gem::Dependency
   name: sqlite3
-  requirement: &70110878836460 !ruby/object:Gem::Requirement
+  requirement: &70188360323440 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -186,7 +186,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70110878836460
+  version_requirements: *70188360323440
 description: ! 'Vines is an XMPP chat server that supports thousands of
 
   simultaneous connections by using EventMachine for asynchronous IO. User data