warden-ldap 0.0.1.pre

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--format progress
+--require './spec/spec_helper'

data/.ruby-version

@@ -0,0 +1 @@
+1.9.3-p392

data/.watchr

@@ -0,0 +1,90 @@
+if __FILE__ == $0
+  puts "Run with: watchr #{__FILE__}. \n\nRequired gems: watchr rev"
+  exit 1
+end
+
+# --------------------------------------------------
+# Convenience Methods
+# --------------------------------------------------
+def run(cmd)
+  sleep(2)
+  puts("%s %s [%s]" % ["|\n" * 5 , cmd , Time.now.to_s])
+  $last_test = cmd
+  system(cmd)
+end
+
+def run_all_specs
+  tags = "--tag #{ARGV[1]}" if ARGV[1]
+  run "bundle exec rake -s spec SPEC_OPTS='--order rand #{tags.to_s}'"
+end
+
+def run_last_test
+  run($last_test)
+end
+
+def run_single_spec *spec
+  tags = "--tag #{ARGV[1]}" if ARGV[1]
+  spec = spec.join(' ')
+  run "bundle exec rspec  #{spec} -d --order rand #{tags}"
+end
+
+def run_specs_with_shared_examples(shared_example_filename, spec_path = 'spec')
+
+  # Returns the names of the shared examples in filename
+  def shared_examples(filename)
+    lines = File.readlines(filename)
+    lines.grep(/shared_examples_for[\s'"]+(.+)['"]\s*[do|\{]/) do |matching_line|
+      $1
+    end
+  end
+
+  # Returns array with filenames of the specs using shared_example
+  def specs_with_shared_example(shared_example, path)
+    command = "grep -lrE 'it_should_behave_like .(#{shared_example}).' #{path}"
+    `#{command}`.split
+  end
+
+  shared_examples(shared_example_filename).each do |shared_example|
+    specs_to_run = specs_with_shared_example(shared_example, spec_path)
+    run_single_spec(specs_to_run) unless specs_to_run.empty?
+  end
+
+end
+
+def run_cucumber_scenario scenario_path
+  if scenario_path !~ /.*\.feature$/
+    scenario_path = $last_scenario
+  end
+  $last_scenario = scenario_path
+  run "bundle exec cucumber #{scenario_path} --tags @dev"
+end
+
+# --------------------------------------------------
+# Watchr Rules
+# --------------------------------------------------
+watch( '^spec/spec_helper\.rb'                    ) { |m| run_last_test }
+watch( '^spec/fixtures/sample_app.*\.rb'          ) {     run_last_test }
+watch( '^spec/.*_spec\.rb'                        ) { |m| run_single_spec(m[0]) }
+watch( '^spec/helpers\/.*\.rb'                        ) { |m| run_last_test }
+watch( '^lib/(.*)\.rb'                            ) { |m| run_last_test }
+
+
+# --------------------------------------------------
+# Signal Handling
+# --------------------------------------------------
+# Ctrl-\
+Signal.trap('QUIT') do
+  puts " --- Running all tests ---\n\n"
+  run_all_specs
+end
+
+# Ctrl-T
+Signal.trap('TSTP') do
+  puts " --- Running last test --\n\n"
+  run_cucumber_scenario nil
+end
+
+# Ctrl-C
+Signal.trap('INT') { abort("\n") }
+
+puts "Watching.." 

data/Gemfile

@@ -0,0 +1,11 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in warden-ldap.gemspec
+gemspec
+
+gem 'rspec'
+
+group :development, :test do
+  gem 'rack'
+  gem 'debugger'
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Maher Hawash
+
+MIT License
+
+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.

data/README.md

@@ -0,0 +1,31 @@
+# Warden::Ldap
+
+**NOTE**: This product is still pre-release, and implementation is *not* in sync with documentation yet - hence the pre-release version.  We'll follow [the Semantic Versioning Specification (Semver)](http://semver.org/), so you can assume anything at 0.x.x still has an unstable API.  But we *are* actively developing this.
+
+LDAP Strategy for Warden
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'warden-ldap'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install warden-ldap
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => [:spec]
+
+Rake::TaskManager.record_task_metadata = true
+

data/lib/warden/ldap/configuration.rb

@@ -0,0 +1,47 @@
+module Warden
+  module Ldap
+
+    # Stores configruation information
+    #
+    # Configruation inforamtion is loaded from a configuration block defined within
+    # the client application.
+    #
+    # @example Standard settings
+    #   Warden::Ldap.configure do |c|
+    #     c.config_file = 'path/to/warden_config.yml'
+    #     # ...
+    #   end
+    #
+    class Configuration
+      class << self
+        def define_setting(name)
+          defined_settings << name
+          attr_accessor name
+        end
+
+        def defined_settings
+          @defined_settings ||= []
+        end
+      end
+
+      define_setting :config_file
+
+      define_setting :env
+
+      define_setting :logger
+
+      def initialize
+        @logger ||= Warden::Ldap::Logger
+      end
+
+      def env
+        if defined? Rails
+          Rails.env
+        elsif @env.nil?
+          raise 'Must define Warden::Ldap.env'
+        end
+        @env
+      end
+    end
+  end
+end

data/lib/warden/ldap/connection.rb

@@ -0,0 +1,104 @@
+require 'yaml'
+
+module Warden
+  module Ldap
+    class Connection
+      attr_reader :ldap, :login
+      def logger
+        Warden::Ldap.logger
+      end
+
+      def initialize(options= {})
+        @login = options.delete(:username)
+        @password = options.delete(:password)
+
+        options[:encryption] = config["ssl"].to_sym if config["ssl"]
+
+        @ldap = Net::LDAP.new(options)
+        @ldap.host = config["host"]
+        @ldap.port = config["port"]
+        @ldap.base = config["base"]
+
+        @generic_credentials = config["generic_credentials"]
+        @attribute = [config["attributes"]].flatten
+      end
+
+      def ldap_param_value(param)
+        ldap_entry = nil
+        @ldap.search(:filter => ldap_username_filter) {|entry| ldap_entry = entry}
+
+        if ldap_entry
+          if ldap_entry[param]
+            logger.info("Requested param #{param} has value #{ldap_entry.send(param)}")
+            value = ldap_entry.send(param)
+            value = value.first if value.is_a?(Array) and value.count == 1
+          else
+            logger.error("Requested param #{param} does not exist")
+            value = nil
+          end
+        else
+          logger.error("Requested ldap entry does not exist")
+          value = nil
+        end
+      end
+
+      def authenticate!
+        if @password
+          @ldap.auth(dn, @password)
+          @ldap.bind
+        end
+      end
+
+      def authenticated?
+        authenticate!
+      end
+
+      def authorized?
+        logger.info("Authorizing user #{dn}")
+        authenticated?
+      end
+
+      def valid_login?
+        !search_for_login.nil?
+      end
+
+      private
+      # Searches the LDAP for the login
+      #
+      # @return [Object] the LDAP entry found; nil if not found
+      def search_for_login
+        logger.info("LDAP search for login: #{@attribute}=#{@login}")
+        ldap_entry = nil
+        @ldap.auth(*@generic_credentials)
+        @ldap.search(:filter => ldap_username_filter) {|entry| ldap_entry = entry}
+        ldap_entry
+      end
+
+      def ldap_username_filter
+        filters = @attribute.map { |att| Net::LDAP::Filter.eq(att, @login) }
+        filters.inject { |a,b| Net::LDAP::Filter.intersect(a, b) }
+      end
+
+      def find_ldap_user(ldap)
+        logger.info("Finding user: #{dn}")
+        ldap.search(:base => dn, :scope => Net::LDAP::SearchScope_BaseObject).try(:first)
+      end
+
+      def config
+        if File.exists?(Warden::Ldap.config_file.to_s)
+          @config = YAML.load_file(Warden::Ldap.config_file.to_s)[Warden::Ldap.env]
+        else
+          {}
+        end
+      end
+
+      def dn
+        logger.info("LDAP dn lookup: #{@attribute}=#{@login}")
+
+        if ldap_entry = search_for_login
+          ldap_entry.dn
+        end
+      end
+    end
+  end
+end

data/lib/warden/ldap/logger.rb

@@ -0,0 +1,15 @@
+module Warden
+  module Ldap
+    class Logger
+      class << self
+        def info(message)
+          STDOUT.puts message
+        end
+
+        def error(message)
+          STDERR.puts message
+        end
+      end
+    end
+  end
+end

data/lib/warden/ldap/strategy.rb

@@ -0,0 +1,33 @@
+require 'ostruct'
+require 'net/ldap'
+
+module Warden
+  module Ldap
+    class Strategy < Warden::Strategies::Base
+      def valid?
+        credentials.all?{|c| c.to_s !~ /^\s*$/}
+      end
+
+      def authenticate!
+        username, password = credentials
+        connection = Warden::Ldap::Connection.new({ :username => username, :password => password })
+        response = connection.authenticate!
+
+        if response
+          user = OpenStruct.new({ :username => username,
+                                  :name => connection.ldap_param_value('cn') })
+          success!(user)
+        else
+          fail!("Could not log in")
+        end
+      rescue Net::LDAP::LdapError
+        fail!("Could not log in")
+      end
+
+      private
+      def credentials
+        params.values_at('username', 'password')
+      end
+    end
+  end
+end

data/lib/warden/ldap/version.rb

@@ -0,0 +1,5 @@
+module Warden
+  module Ldap
+    VERSION = "0.0.1.pre"
+  end
+end

data/lib/warden/ldap.rb

@@ -0,0 +1,31 @@
+require "warden/ldap/version"
+require "warden/ldap/logger"
+require "warden/ldap/configuration"
+require "warden/ldap/connection"
+require "warden/ldap/strategy"
+
+module Warden
+  module Ldap
+    class << self
+      extend Forwardable
+      Configuration.defined_settings.each do |setting|
+        def_delegators :configuration, setting, "#{setting.to_s}="
+      end
+
+      def configure
+        yield configuration if block_given?
+      end
+
+      def configuration
+        @configuration ||= Configuration.new
+      end
+
+      def register
+        Warden::Strategies.add(:ldap, Warden::Ldap::Strategy)
+      end
+    end
+  end
+end
+
+Warden::Ldap.register
+

data/spec/fixtures/warden_ldap.yml

@@ -0,0 +1,30 @@
+## Authorizations
+# Uncomment out the merging for each enviornment that you'd like to include.
+# You can also just copy and paste the tree (do not include the "authorizations") to each
+# enviornment if you need something different per enviornment.
+authorizations: &AUTHORIZATIONS
+  group_base: ou=groups,dc=test,dc=com
+  ## Requires config.ldap_check_group_membership in devise.rb be true
+  # Can have multiple values, must match all to be authorized
+  required_groups:
+    # If only a group name is given, membership will be checked against "uniqueMember"
+    - cn=admins,ou=groups,dc=test,dc=com
+    - cn=users,ou=groups,dc=test,dc=com
+    # If an array is given, the first element will be the attribute to check against, the second the group name
+    - ["moreMembers", "cn=users,ou=groups,dc=test,dc=com"]
+  ## Requires config.ldap_check_attributes in devise.rb to be true
+  ## Can have multiple attributes and values, must match all to be authorized
+  require_attribute:
+    objectClass: inetOrgPerson
+    authorizationRole: postsAdmin
+
+  host: your.ldap.host.com
+  port: 389
+  attributes: [uid, cn, mail, samAccountName]
+  base: ou=users,ou=accounts,dc=ds,dc=renewfund,dc=com
+  generic_credentials: [bindaccount, ahead-example-seems-label]
+#  ssl: start_tls
+  # <<: *AUTHORIZATIONS
+
+test: 
+  <<: *AUTHORIZATIONS

data/spec/helpers/rack_helpers.rb

@@ -0,0 +1,50 @@
+require 'warden'
+require 'rack'
+module Warden::Ldap::Helpers
+  module RackHelpers
+    def env_with_params(path = "/", params = {}, env = {})
+      method = params.delete(:method) || "GET"
+      env = { 'HTTP_VERSION' => '1.1', 'REQUEST_METHOD' => "#{method}" }.merge(env)
+      Rack::MockRequest.env_for("#{path}?#{Rack::Utils.build_query(params)}", env)
+    end
+
+    def setup_rack(app=nil, opts = {}, &block)
+      app ||= block if block_given?
+
+      opts[:failure_app]         ||= failure_app
+      opts[:default_strategies]  ||= [:ldap]
+      opts[:default_serializers] ||= [:session]
+      blk = opts[:configurator] || proc{}
+
+      Rack::Builder.new do
+        use opts[:session] || RackHelpers::Session
+        use Warden::Manager, opts, &blk
+        run app
+      end
+    end
+
+    def valid_response
+      Rack::Response.new("OK").finish
+    end
+
+    def failure_app
+      lambda{|e|[401, {"Content-Type" => "text/plain"}, ["You Fail!"]] }
+    end
+
+    def success_app
+      lambda{|e|[200, {"Content-Type" => "text/plain"}, ["You Rock!"]] }
+    end
+
+    class Session
+      attr_accessor :app
+      def initialize(app,configs = {})
+        @app = app
+      end
+
+      def call(e)
+        e['rack.session'] ||= {}
+        @app.call(e)
+      end
+    end # session
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,25 @@
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# Require this file using `require "spec_helper"` to ensure that it is only
+# loaded once.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+
+Dir[File.join(File.dirname(__FILE__), "helpers", "**/*.rb")].each do |f|
+  require f
+end
+
+require File.join(File.dirname(__FILE__), '../lib/warden/ldap')
+
+RSpec.configure do |config|
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+  config.run_all_when_everything_filtered = true
+  config.filter_run :focus
+  config.include(Warden::Ldap::Helpers::RackHelpers)
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/warden/ldap/connection_spec.rb

@@ -0,0 +1,26 @@
+describe Warden::Ldap::Connection do
+  describe '#authentiate!' do
+    it 'does nothing if no password present' do
+      subject = described_class.new({'username' => 'bob'})
+      subject.authenticate!.should be_false
+    end
+
+    it 'authenticates and binds to ldap adapter' do
+      subject = described_class.new({:username => 'bob', :password => 'secret'})
+      subject.stub(:dn => 'Sammy')
+      Net::LDAP.any_instance.should_receive(:auth).with('Sammy', 'secret')
+      Net::LDAP.any_instance.should_receive(:bind).and_return(true)
+      subject.authenticate!.should be_true
+    end
+
+    it 'actually authenticates' do
+      Warden::Ldap.configure do |c|
+        c.config_file = "/Users/mhawash/src/hummingbird/config/ldap.yml"
+        c.env = 'production'
+      end
+
+      subject = described_class.new({:username => 'mhawash', :password => 'sarra1216'})
+    p  subject.authenticate!
+    end
+  end
+end

data/spec/warden/ldap/strategy_spec.rb

@@ -0,0 +1,48 @@
+describe Warden::Ldap::Strategy do
+  subject {described_class.new(@env)}
+
+  describe '#valid?' do
+
+    it 'returns true if both username and password are passed in' do
+      @env = env_with_params("/", {'username' => 'test', 'password' => 'secret'})
+      subject.valid?.should be_true
+    end
+
+    it 'returns false if password is missing' do
+      @env = env_with_params("/", {'username' => 'test'})
+      subject.valid?.should be_false
+    end
+
+    it 'returns false if password is blank' do
+      @env = env_with_params("/", {'username' => 'test', 'password' => ''})
+      subject.valid?.should be_false
+    end
+  end
+
+  describe '#authenticte!' do
+    before :each do
+      @env = env_with_params("/", {'username' => 'test', 'password' => 'secret'})
+      subject.stub(:valid? => true)
+    end
+
+    it 'succeeds if the ldap connection succeeds' do
+      Warden::Ldap::Connection.any_instance.stub(:authenticate! => true)
+      Warden::Ldap::Connection.any_instance.stub(:ldap_param_value).with('cn').and_return('Samuel')
+      subject.should_receive(:success!)
+      subject.authenticate!
+    end
+
+    it 'fails if ldap connection fails' do
+      Warden::Ldap::Connection.any_instance.stub(:authenticate! => false)
+      subject.should_receive(:fail!)
+      subject.authenticate!
+    end
+
+    it 'fails if Net::LDAP::LdapError was raised' do
+      Warden::Ldap::Connection.any_instance.stub(:authenticate!).and_raise(Net::LDAP::LdapError)
+      subject.should_receive(:fail!)
+      subject.authenticate!
+    end
+
+  end
+end

data/spec/warden/ldap_spec.rb

@@ -0,0 +1,44 @@
+describe Warden::Ldap do
+  before :each do
+    described_class.configure do |c|
+      c.config_file = File.join(File.dirname(__FILE__), '../fixtures/warden_ldap.yml')
+    end
+  end
+
+  it 'returns 401 if not authenticated' do
+    env = env_with_params("/", {'username' => 'test'})
+    app = lambda do |env|
+      env['warden'].authenticate(:ldap)
+      throw(:warden)
+    end
+    result = setup_rack(app).call(env)
+    result.first.should == 401
+    result.last.should == ["You Fail!"]
+  end
+
+  it 'returns 200 if authenticates properly' do
+    env = env_with_params("/", {'username' => 'bobby', 'password' => 'joel'})
+    app = lambda do |env|
+      env['warden'].authenticate(:ldap)
+      success_app.call(env)
+    end
+    Warden::Ldap::Connection.any_instance.stub(:authenticate! => true)
+    Warden::Ldap::Connection.any_instance.stub(:ldap_param_value).with('cn').and_return('Samuel')
+    result = setup_rack(app).call(env)
+    result.first.should == 200
+    result.last.should == ["You Rock!"]
+  end
+
+  it 'returns authenticated user information' do
+    env = env_with_params("/", {'username' => 'bobby', 'password' => 'joel'})
+    app = lambda do |env|
+      env['warden'].authenticate(:ldap)
+      success_app.call(env)
+    end
+    Warden::Ldap::Connection.any_instance.stub(:authenticate! => true)
+    Warden::Ldap::Connection.any_instance.stub(:ldap_param_value).with('cn').and_return('Samuel')
+    result = setup_rack(app).call(env)
+    env['warden'].user.username.should == 'bobby'
+    env['warden'].user.name.should == 'Samuel'
+  end
+end

data/warden-ldap.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'warden/ldap/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "warden-ldap"
+  spec.version       = Warden::Ldap::VERSION
+  spec.authors       = ["Maher Hawash"]
+  spec.email         = ["gmhawash@gmail.com"]
+  spec.description   = %q{Provides ldap strategy for warden}
+  spec.summary       = %q{Provides ldap strategy for wrden}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_runtime_dependency "warden", '~> 1.2.1'
+  spec.add_runtime_dependency "net-ldap", '~> 0.3.1'
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: warden-ldap
+version: !ruby/object:Gem::Version
+  version: 0.0.1.pre
+  prerelease: 6
+platform: ruby
+authors:
+- Maher Hawash
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-05-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: warden
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+- !ruby/object:Gem::Dependency
+  name: net-ldap
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.1
+description: Provides ldap strategy for warden
+email:
+- gmhawash@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rspec
+- .ruby-version
+- .watchr
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/warden/ldap.rb
+- lib/warden/ldap/configuration.rb
+- lib/warden/ldap/connection.rb
+- lib/warden/ldap/logger.rb
+- lib/warden/ldap/strategy.rb
+- lib/warden/ldap/version.rb
+- spec/fixtures/warden_ldap.yml
+- spec/helpers/rack_helpers.rb
+- spec/spec_helper.rb
+- spec/warden/ldap/connection_spec.rb
+- spec/warden/ldap/strategy_spec.rb
+- spec/warden/ldap_spec.rb
+- warden-ldap.gemspec
+homepage: ''
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -2051351063243103119
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: Provides ldap strategy for wrden
+test_files:
+- spec/fixtures/warden_ldap.yml
+- spec/helpers/rack_helpers.rb
+- spec/spec_helper.rb
+- spec/warden/ldap/connection_spec.rb
+- spec/warden/ldap/strategy_spec.rb
+- spec/warden/ldap_spec.rb