ldap_disambiguate 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 76ca8867744e6cb0102707bf64529554acdccd14
+  data.tar.gz: 3a7fc8ab6ca648fd67d0113ca541968123d37f37
+SHA512:
+  metadata.gz: b25d698df46f01b22f019cbfa79f337729e4be4f655862d6261623df0a58aaafd5fc2e13de26ab0d2345a943ca5e2a1bb76eaec044b4aeac7dc0fb101a45aa3e
+  data.tar.gz: ded15695850d2820b7cb4c98662fc8f6a58efb93b7478647b20e966437a7830d8144c4bf10f086254f9091e00a6637cb1dd26aa46e50514b44d3d8fb6373d5f3

data/.gitignore

@@ -0,0 +1,12 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/bin/
+.ruby-version
+config/hydra-ldap.yml

data/.rubocop.yml

@@ -0,0 +1,57 @@
+AllCops:
+  DisplayCopNames: true
+  Include:
+    - '**/Rakefile'
+
+Metrics/LineLength:
+  Enabled: false
+
+Metrics/AbcSize:
+  Enabled: false
+
+Style/IndentationConsistency:
+  EnforcedStyle: rails
+
+Style/CollectionMethods:
+  PreferredMethods:
+    collect: 'map'
+    collect!: 'map!'
+    inject: 'reduce'
+    detect: 'find'
+    find_all: 'select'
+
+Style/WordArray:
+  Enabled: false
+
+Style/RegexpLiteral:
+  Enabled: false
+
+Style/StringLiterals:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/SingleLineBlockParams:
+  Enabled: false
+
+Style/SignalException:
+  Enabled: false
+
+RSpec/ExampleWording:
+  CustomTransform:
+    be: is
+    have: has
+    not: does not
+    NOT: does NOT
+  IgnoredWords:
+    - only
+
+RSpec/FilePath:
+  Enabled: false
+
+RSpec/InstanceVariable:
+  Enabled: false

data/.rubocop_todo.yml

@@ -0,0 +1,19 @@
+# This configuration was generated by
+# `rubocop --auto-gen-config`
+# on 2016-03-24 06:26:32 -0400 using RuboCop version 0.37.2.
+# The point is for the user to remove these configuration records
+# one by one as the offenses are removed from the code base.
+# Note that changes in the inspected code, or installation of new
+# versions of RuboCop, may require this file to be generated again.
+
+# Offense count: 1
+# Configuration parameters: CountComments.
+Metrics/ClassLength:
+  Max: 111
+
+# Offense count: 1
+Style/Documentation:
+  Exclude:
+    - 'spec/**/*'
+    - 'test/**/*'
+    - 'lib/ldap_disambiguate.rb'

data/.travis.yml

@@ -0,0 +1,10 @@
+language: ruby
+cache: bundler
+rvm:
+  - 2.3.0
+before_script:
+  - "cp config/hydra-ldap.yml.sample config/hydra-ldap.yml"
+notifications:
+  irc:
+    channels:
+      - "irc.freenode.org#scholarsphere"

data/Gemfile

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in share_notify.gemspec
+gemspec
+
+gem 'byebug'
+gem 'rubocop', require: false
+gem 'rubocop-rspec', require: false

data/README.md

@@ -0,0 +1,44 @@
+# ldap_disambiguate
+Use ldap to disambiguate a user name against the PSU LDAP.
+
+## Useage
+
+Instantiate the servercive with a string `LdapDisambiguate::Name.new("jbd123")`
+Call the disambiguate method which returns an array of people in the format `[{:id=>"jbd123", :given_name=>"Jane B", :surname=>"Doe", :email=>"jbd123@psu.edu", :affiliation=>["STAFF"]}]`
+
+What you pass in as the nam can vary from an id to a list of names and or emails.
+
+### Basic usage with a id
+
+You can call dismabiguate with an id, which then call ldap and returns a record containing the 
+
+```
+service = LdapDisambiguate::Name.new("cam156") # #<LdapDisambiguate::Name:0x007fab36190710 @name="cam156", @email_for_name_cache={}, @results=[]>
+service.disambiguate #[{:id=>"cam156", :given_name=>"CAROLYN A", :surname=>"COLE", :email=>"cam156@psu.edu", :affiliation=>["STAFF"]}]
+```
+
+### Basic usage with a name
+
+```
+service = LdapDisambiguate::Name.new("Carolyn Cole") # #<LdapDisambiguate::Name:0x007fab36190710 @name="Carolyn Cole", @email_for_name_cache={}, @results=[]>
+service.disambiguate #[{:id=>"cam156", :given_name=>"CAROLYN A", :surname=>"COLE", :email=>"cam156@psu.edu", :affiliation=>["STAFF"]}]
+```
+
+### Useage with last name and first name part
+```
+service = LdapDisambiguate::Name.new("Carol Cole") # #<LdapDisambiguate::Name:0x007fab36190710 @name="Carol Cole", @email_for_name_cache={}, @results=[]>
+service.disambiguate #[{:id=>"cam156", :given_name=>"CAROLYN A", :surname=>"COLE", :email=>"cam156@psu.edu", :affiliation=>["STAFF"]}]
+```
+
+### Useage with last name and first name part
+```
+service = LdapDisambiguate::Name.new("Carol Cole, cam156") # #<LdapDisambiguate::Name:0x007fab36190710 @name="Carol Cole", @email_for_name_cache={}, @results=[]>
+service.disambiguate #[{:id=>"cam156", :given_name=>"CAROLYN A", :surname=>"COLE", :email=>"cam156@psu.edu", :affiliation=>["STAFF"]}]
+```
+
+### Useage with a list of names
+```
+service = LdapDisambiguate::Name.new("Carol Cole; Adam Wead") ##<LdapDisambiguate::Name:0x007fab32cf2418 @name="Carol Cole; Adam Wead", @email_for_name_cache={}, @results=[]>
+service.disambiguate #[{:id=>"cam156", :given_name=>"CAROLYN A", :surname=>"COLE", :email=>"cam156@psu.edu", :affiliation=>["STAFF"]}, {:id=>"agw13", :given_name=>"ADAM GARNER", :surname=>"WEAD", :email=>"agw13@psu.edu", :affiliation=>["STAFF"]}]
+```
+

data/Rakefile

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+Bundler::GemHelper.install_tasks
+
+Dir.glob('tasks/*.rake').each { |r| import r }
+
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+desc "Run style checker"
+RuboCop::RakeTask.new(:rubocop) do |task|
+  task.requires << 'rubocop-rspec'
+  task.fail_on_error = true
+end
+
+desc "Run continuous integration tests"
+task ci: [:rubocop, :spec]
+
+task default: :ci

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/config/hydra-ldap.yml.sample

@@ -0,0 +1,24 @@
+development:
+  host: ldap.example.com
+  port: 389
+  # username: cn=admin,dc=example,dc=com
+  # password: simple77
+  group_base: dc=psu,dc=edu
+  base: dc=example,dc=com
+  uid: uid
+test:
+  host: ldap.example.com
+  port: 389
+  # username: cn=admin,dc=example,dc=com
+  # password: simple77
+  group_base: dc=psu,dc=edu
+  # base: dc=example,dc=com
+  # uid: uid
+production:
+  host: ldap.example.com
+  port: 389
+  #username: cn=admin,dc=example,dc=com
+  #password: <%= ENV['LDAP_PASSWORD'] %>
+  group_base: dc=psu,dc=edu
+  base: dc=example,dc=com
+  uid: uid

data/ldap_disambiguate.gemspec

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ldap_disambiguate/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'ldap_disambiguate'
+  s.version     = LdapDisambiguate::VERSION
+  s.date        = '2016-03-14'
+  s.summary     = 'Use ldap to diambiguate a text name'
+  s.description = 'Queries the PSU ldap to see if it can find a user that matches the text to get the prefered name and email'
+  s.authors     = ['Carolyn Cole']
+  s.email       = 'cam156@psu.edu'
+  s.files       = ['lib/ldap_disambiguate.rb']
+  s.homepage    =
+    'https://github.com/psu-stewardship/ldap_disambiguate'
+  s.license       = 'APACHE2'
+
+  s.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  s.bindir        = 'exe'
+  s.executables   = s.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  s.require_paths = ['lib']
+
+  s.add_dependency 'hydra-ldap'
+  s.add_dependency 'net-ldap', '0.13.0'
+  s.add_dependency 'namae', '0.9.3'
+
+  s.add_development_dependency 'bundler', '~> 1.11'
+  s.add_development_dependency 'rake', '~> 10.0'
+  s.add_development_dependency 'rspec', '~> 3.0'
+  s.add_development_dependency 'rspec-its'
+end

data/lib/ldap_disambiguate.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+# require 'rspec/its'
+require 'net-ldap'
+require 'hydra-ldap'
+require 'namae'
+require 'logger'
+
+def logger
+  Logger.new(STDOUT)
+end
+
+# defines the classes availabel for the LdapDisambiguate gem
+#
+# LdapUser is the interface to the PSU LDAP
+# Name uses the name to disambiguate via name
+#
+module LdapDisambiguate
+  autoload :Base, 'ldap_disambiguate/base'
+  autoload :Name, 'ldap_disambiguate/name'
+  autoload :Email, 'ldap_disambiguate/email'
+  autoload :LdapUser, 'ldap_disambiguate/ldap_user'
+end

data/lib/ldap_disambiguate/base.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+module LdapDisambiguate
+  # This class allows you to use LDAP to disambiguate a text name
+  #
+  class Base
+    class << self
+      private
+
+      def ldap_attributes_for_id(id)
+        attrs = LdapUser.directory_attributes(id, ldap_attrs)
+        return nil if attrs.count < 1
+        [results_hash(attrs.first)]
+      end
+
+      def results_hash(opts)
+        {
+          id:          fetch(opts, :uid).first,
+          given_name:  fetch(opts, :givenname).first,
+          surname:     fetch(opts, :sn).first,
+          email:       fetch(opts, :mail).first,
+          affiliation: fetch(opts, :eduPersonPrimaryAffiliation, []),
+          displayname: fetch(opts, :displayname).first
+        }
+      end
+
+      def fetch(opts, key, default = [''])
+        opts[key].blank? ? default : opts[key]
+      end
+
+      def ldap_attrs
+        [:uid, :givenname, :sn, :mail, :eduPersonPrimaryAffiliation, :displayname]
+      end
+    end
+  end
+end

data/lib/ldap_disambiguate/email.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+module LdapDisambiguate
+  # This class allows you to use LDAP to extract user information
+  #  from an email or list of emails
+  #
+  class Email < Base
+    class << self
+      def disambiguate(email)
+        return unless email.include?('@')
+        email_in_name(email)
+      end
+
+      private
+
+      def email_in_name(email_list)
+        parts = email_list.split(' ')
+        emails = parts.reject { |part| !part.include?('@') }
+        results = []
+        Array(emails).each do |email|
+          id = email.split('@')[0]
+          results << (ldap_attributes_for_id(id) || [results_hash(mail: [email])]).first
+        end
+        results
+      end
+    end
+  end
+end

data/lib/ldap_disambiguate/ldap_user.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+module LdapDisambiguate
+  # This class provides an api for quering LDAP with different portions of the user's
+  # information (name parts or id)
+  class LdapUser
+    class << self
+      def directory_attributes(login, attrs = [])
+        filter = Net::LDAP::Filter.eq('uid', login)
+        get_ldap_response(:get_user, filter, attrs)
+      end
+
+      def query_ldap_by_name_or_id(id_or_name_part)
+        filter = Net::LDAP::Filter.construct("(& (| (uid=#{id_or_name_part}* ) (givenname=#{id_or_name_part}*) (sn=#{id_or_name_part}*)) #{person_filter})")
+        users  = get_ldap_response(:get_user, filter, %w(uid displayname))
+
+        # handle the issue that searching with a few letters returns more than 1000 items wich causes an error in the system
+        users = get_user_by_partial_id(id_or_name_part) if size_limit_exceeded?
+        users.map { |u| { id: u[:uid].first, text: "#{u[:displayname].first} (#{u[:uid].first})" } }
+      end
+
+      def query_ldap_by_name(given_name, surname, attrs = [])
+        return if given_name.blank? # this method only work if we have a first name to play with
+
+        first_names = given_name.split(/[\s.]+/)
+        users = []
+        name_filters(first_names[0], first_names[1], surname).each do |filter|
+          users = get_users(filter, attrs)
+          break if users.count > 0 # stop running through the filters if we get results
+        end
+        format_users(users, attrs)
+      end
+
+      def get_users(name_filter, attrs = [])
+        attrs = (attrs + default_attributes).uniq
+        person_filter = '(| (eduPersonPrimaryAffiliation=STUDENT) (eduPersonPrimaryAffiliation=FACULTY) (eduPersonPrimaryAffiliation=STAFF) (eduPersonPrimaryAffiliation=EMPLOYEE) (eduPersonPrimaryAffiliation=RETIREE) (eduPersonPrimaryAffiliation=EMERITUS) (eduPersonPrimaryAffiliation=MEMBER)))'
+        filter = Net::LDAP::Filter.construct("(& (& #{name_filter}) #{person_filter})")
+        get_ldap_response(:get_user, filter, attrs)
+      end
+
+      private
+
+      def format_users(users, attrs)
+        user_attrs = attrs - default_attributes
+        users.map { |u| format_user(u, user_attrs) }
+      end
+
+      def format_user(user, extra_attrs)
+        hash = { id: user[:uid].first, given_name: user[:givenname].first, surname: user[:sn].first, email: user[:mail].first, affiliation: user[:eduPersonPrimaryAffiliation] }
+        extra_attrs.each { |attr| hash[attr] = user[attr].first }
+        hash
+      end
+
+      def get_user_by_partial_id(_id)
+        filter = Net::LDAP::Filter.construct("(& (uid=#{id_or_name_part}* ) #{person_filter})")
+        get_ldap_response(:get_user, filter, %w(uid displayname))
+      end
+
+      def get_ldap_response(_method, filter, attributes)
+        tries.times.each do
+          result = Hydra::LDAP.get_user(filter, attributes)
+          return result unless unwilling?
+          sleep(sleep_time)
+        end
+        nil
+      end
+
+      def tries
+        7
+      end
+
+      # Numeric code returned by LDAP if it is feeling "unwilling"
+      def unwilling?
+        Hydra::LDAP.connection.get_operation_result.code == 53
+      end
+
+      def size_limit_exceeded?
+        Hydra::LDAP.connection.get_operation_result[:message] == 'Size Limit Exceeded'
+      end
+
+      def sleep_time
+        1.0
+      end
+
+      def person_filter
+        '(| (eduPersonPrimaryAffiliation=STUDENT) (eduPersonPrimaryAffiliation=FACULTY) (eduPersonPrimaryAffiliation=STAFF) (eduPersonPrimaryAffiliation=EMPLOYEE))))'
+      end
+
+      def name_filters(first_name, middle_name, surname)
+        filters = []
+        filters << "(givenname=#{first_name}*) (givenname=* #{middle_name}*) (sn=#{surname})" unless middle_name.blank?
+        filters << "(givenname=#{first_name}) (sn=#{surname})"
+        filters << "(givenname=#{first_name}*) (sn=#{surname})"
+        filters << "(givenname=*#{first_name}*) (sn=#{surname})"
+        filters
+      end
+
+      def default_attributes
+        [:uid, :givenname, :sn, :mail, :eduPersonPrimaryAffiliation]
+      end
+    end
+  end
+end

data/lib/ldap_disambiguate/name.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+module LdapDisambiguate
+  # This class allows you to use LDAP to disambiguate a text name
+  #
+  class Name < Base
+    class << self
+      def disambiguate(name)
+        return if name.blank?
+        results = ldap_attributes_for_id(name) # text includes login id
+        results ||= Email.disambiguate(name) # text includes email(s)
+        results ||= text_only_names(name) # straight text we need to query ldap
+        results
+      end
+
+      private
+
+      def text_only_names(multi_name)
+        results = []
+        multi_name.split(/and|;/).each do |n|
+          n.gsub!(/\([^)]*\)/, '')
+          n.strip!
+          query_result = email_for_name(n)
+          query_result ||= title_after_name(n) # try again without the titles
+          results << query_result unless query_result.blank?
+        end
+        results
+      end
+
+      # titles after the name that namae had trouble parsing
+      def title_after_name(text_name)
+        result = nil
+        if text_name.count(',') > 0
+          new_name = text_name.split(',')[0]
+          result = email_for_name(new_name) if new_name.count(' ') > 0
+        end
+        result
+      end
+
+      def email_for_name(text_name)
+        return '' if text_name.blank?
+        return email_for_name_cache[text_name] unless email_for_name_cache[text_name].blank?
+
+        email_for_name_cache[text_name] = find_email_for_name(text_name)
+        email_for_name_cache[text_name]
+      end
+
+      def email_for_name_cache
+        @email_for_name_cache ||= {}
+      end
+
+      def find_email_for_name(text_name)
+        text_name.gsub!(/[^\w\s,']/, ' ')
+        parsed = Namae::Name.parse(text_name)
+        result = try_name(parsed.given, parsed.family)
+        result ||= title_before_name(parsed)
+        result ||= two_words_in_last_name(text_name)
+
+        logger.error("got zero for #{text_name}") if result.nil?
+        result
+      end
+
+      def try_name(given, family)
+        return nil if family.blank?
+        possible_users = LdapUser.query_ldap_by_name(given, family, ldap_attrs)
+        return nil if possible_users.count == 0
+        if possible_users.count > 1
+          logger.error("Returning #{possible_users.first} but got more than name for given name #{given} and family name #{name}")
+          return nil
+        end
+        possible_users.first
+      end
+
+      def name_parts(text_name, last_name_count)
+        parts = text_name.split(' ')
+        first_name_count = parts.count - last_name_count
+        return nil if first_name_count < 1
+        { given: parts.first(first_name_count).join(' '), family: parts.last(last_name_count).join(' ') }
+      end
+
+      # take first name and break it into first and last with last name conatining one word
+      def title_before_name(parsed)
+        return unless parsed
+        result = nil
+        if parsed.given && parsed.given.count(' ') >= 1
+          parts = name_parts(parsed.given, 1)
+          result = try_name(parts[:family], parsed.family)
+        end
+        result
+      end
+
+      def two_words_in_last_name(text_name)
+        result = nil
+        if text_name.count(' ') > 2
+          parts = name_parts(text_name, 2)
+          result = try_name(parts[:given], parts[:family])
+        end
+        result
+      end
+  end
+  end
+end

data/lib/ldap_disambiguate/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module LdapDisambiguate
+  VERSION = '0.0.1'.freeze
+end

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification
+name: ldap_disambiguate
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Carolyn Cole
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-03-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: hydra-ldap
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: net-ldap
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.13.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.13.0
+- !ruby/object:Gem::Dependency
+  name: namae
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.9.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.9.3
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: rspec-its
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Queries the PSU ldap to see if it can find a user that matches the text
+  to get the prefered name and email
+email: cam156@psu.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- ".rubocop_todo.yml"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- VERSION
+- config/hydra-ldap.yml.sample
+- ldap_disambiguate.gemspec
+- lib/ldap_disambiguate.rb
+- lib/ldap_disambiguate/base.rb
+- lib/ldap_disambiguate/email.rb
+- lib/ldap_disambiguate/ldap_user.rb
+- lib/ldap_disambiguate/name.rb
+- lib/ldap_disambiguate/version.rb
+homepage: https://github.com/psu-stewardship/ldap_disambiguate
+licenses:
+- APACHE2
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: Use ldap to diambiguate a text name
+test_files: []