wobaduser 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b28543ca5d946a4e698ad38bd4b29c492a7ac1b8
+  data.tar.gz: adccab4655ae479b566d8fa8ff23adee912b5011
+SHA512:
+  metadata.gz: f97d54312d98d9faa83f77079c4131f4c7aa76f7be52ebf2709d59aa4987b879599a8deff312d7fbbe60f512566e86ed5ea5b5a8fd2a2b3a71cefd0ff777aa0e
+  data.tar.gz: 2ffd81aa1db62405afd8eb596c06c27cb123c84ffc99fdc0b02081f6c05284a74c49dacea90492c69f0c42c91fcbcbd04bb46453be9aa7e99023f90415ed5426

data/.gitignore

@@ -0,0 +1,25 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log
+.*.swp
+utils/
+.localenv

data/.rspec

@@ -0,0 +1,2 @@
+--color
+--format progress

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in wobaduser.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2018 Wolfgang Barth
+
+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,14 @@
+wobaduser
+=========
+
+Lightweight Active Directory access.
+
+If you are looking for a full featured solution to access and modify Active Directory, see [https://github.com/ajrkerr/active_directory](https://github.com/ajrkerr/active_directory)
+
+Licence
+-------
+
+wobauth Copyright (C) 2014-2018  Wolfgang Barth
+
+MIT license, see [LICENSE](LICENSE)
+

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/string_addons.rb

@@ -0,0 +1,5 @@
+class String
+  def as_utf8
+    self.force_encoding('UTF-8')
+  end
+end

data/lib/wobaduser.rb

@@ -0,0 +1,19 @@
+require "wobaduser/version"
+require 'net/ldap'
+require 'active_support/core_ext/module'
+require 'active_support/core_ext/hash'
+require 'string_addons'
+
+module Wobaduser
+  autoload :LDAP, 'wobaduser/ldap'
+  autoload :Base, 'wobaduser/base'
+  autoload :User, 'wobaduser/user'
+
+  def self.setup
+    yield self
+  end
+
+  # timeout for ldap connections
+  mattr_accessor :timeout
+  @@timeout = 10
+end

data/lib/wobaduser/base.rb

@@ -0,0 +1,174 @@
+# additional copyright info:
+# the metaprogramming for generate_single_value_readers and
+# generate_multi_value_readers was published 2008 by Ernie Miller on
+# http://erniemiller.org/2008/04/04/simplified-active-directory-authentication/
+# with an excellent explanation.
+#
+require 'immutable-struct'
+
+module Wobaduser
+  class Base
+    SearchResult = ImmutableStruct.new( :success?, :errors, :entries )
+
+    ###################################################################
+    # ATTR_SV is for single valued attributes only. result is a string.
+    # ATTR_MV is for multi valued attributes. result is an array.
+    # Concrete values should be set in subclasses. See Wobaduser::User 
+    # for an example.
+    #
+    ATTR_SV={}
+    ATTR_MV={}
+    #
+    ###################################################################
+
+    attr_reader :errors, :entry
+
+    # Create an new Wobaduser object
+    # not to be intended to call directly, but possible. Better to use 
+    # Wobaduser::User.new or Wobaduser::Group.new. There are to modes:
+    # 1) use Wobaduser::LDAP + LDAP-Filter
+    # 2) use a retrieved LDAP entry, i.e. used in Wobaduser::Base.search
+    # 
+    # [+:entry+]	ldap entry
+    # [+:ldap+]		instance of Wobaduser::LDAP
+    # [+:filter+]	ldap filter (as string, *not* as Net::LDAP::Filter)
+    # [+:ldap_options+]	additional ldap options for search
+    # 
+    # :entry and (:ldap, :filter) are mutually exclusive
+    # 
+    def initialize(options = {})
+      options.symbolize_keys!
+      keys = options.keys
+      if keys.include?(:entry) && (keys & [:ldap, :filter, :ldap_options]).any?
+        raise ArgumentError, ":entry and one of (:ldap, :filter, :ldap_options) are mutually exclusive!"
+      end
+      reset_errors
+      get_ldap_entry(options)
+      unless entry.nil?
+        self.class.class_eval do
+          generate_single_value_readers
+          generate_multi_value_readers
+        end
+      end
+    end
+
+    def self.search(options = {})
+      search = search_ldap_entries(options)
+      if search.success?
+        entries = search.entries.map {|entry| self.new(entry: entry)}
+        result = SearchResult.new(success: true, errors: [], entries: entries)
+      else
+        result = SearchResult.new(success: false, errors: search.errors, entries: [])
+      end
+    end
+
+    def self.filter
+      Net::LDAP::Filter.present('objectClass')
+    end
+
+    def valid?
+      @entry.kind_of? Net::LDAP::Entry
+    end
+
+    protected
+
+    #
+    # method generator for single value attributes defined in ATTR_SV
+    #
+    def self.generate_single_value_readers
+      return if ATTR_SV.nil?
+      self::ATTR_SV.each_pair do |k, v|
+	val, block = Array(v)
+	define_method(k) do
+	  if @entry.attribute_names.include?(val)
+	    attribute = @entry.send(val)
+	    attribute = attribute.first if attribute.is_a? Array
+	    if block.is_a?(Proc)
+	      final = block[attribute.to_s]
+	    else
+	      final = attribute.to_s
+	    end
+	    final = final.force_encoding('UTF-8') if final.is_a? String
+	    return final
+	  else
+	    return ''
+	  end
+	end
+      end
+    end
+
+    #
+    # method generator for multi value attributes defined in ATTR_MV
+    #
+    def self.generate_multi_value_readers
+      return if ATTR_SV.nil?
+      self::ATTR_MV.each_pair do |k, v|
+	val, block = Array(v)
+	define_method(k) do
+	  if @entry.attribute_names.include?(val)
+	    if block.is_a?(Proc)
+	      finals = @entry.send(val).collect(&block)
+	    else
+	      finals = @entry.send(val)
+	    end
+	    finals = finals.map{|v| v.is_a?(String) ? v.to_s.force_encoding('UTF-8') : v } if finals.is_a? Array   
+	    return finals.compact
+	  else
+	    return []
+	  end
+	end
+      end
+    end
+
+    def self.search_ldap_entries(options)
+      ldap = options.fetch(:ldap)
+      if ldap.nil?
+        raise "ldap connection not yet available"
+      end
+      filter = options.fetch(:filter)
+      ldap_options = options.fetch(:ldap_options, {}).
+                       merge(filter: build_filter(filter))
+      entries = ldap.search(ldap_options)
+      if ldap.errors.any?
+        result = SearchResult.new(success: false, errors: ldap.errors, entries: [])
+      else
+        result = SearchResult.new(success: true, errors: [], entries: entries)
+      end
+    end
+
+    def self.build_filter(filter)
+      unless filter.kind_of? Net::LDAP::Filter
+        filter = Net::LDAP::Filter.construct(filter)
+      end
+      filter & self.filter
+    end
+
+  protected
+
+    def add_error(message)
+      @errors << message
+    end
+
+    def reset_errors
+      @errors = []
+    end
+
+  private
+
+    def get_ldap_entry(options)
+      if options.keys.include?(:entry)
+        @entry = options.fetch(:entry)
+        reset_errors
+      else
+        result = Wobaduser::Base.search_ldap_entries(options)
+        if result.success?
+          @entry = result.entries.first
+        else
+          add_error(result.errors.join(", "))
+          @entry = nil
+        end
+      end
+    end
+
+  end
+end

data/lib/wobaduser/ldap.rb

@@ -0,0 +1,84 @@
+require 'timeout'
+require 'net/ldap'
+
+module Wobaduser
+  class LDAP
+    attr_reader :ldap_options, :errors
+
+    # Wobaduser::LDAP.new({ldap_options: {}, bind: true})
+    #
+    # [+:ldap_options+]   for possible ldap options see Net::LDAP::new
+    # [+:bind+]           true: bind on initialize, false: bind on later operations
+    #
+    def initialize(options = {})
+      options.symbolize_keys!
+      reset_errors
+      @ldap_options = options.fetch(:ldap_options).symbolize_keys!
+      do_bind = options.fetch(:bind, true)
+      connection(ldap_options: @ldap_options, bind: do_bind)
+    end
+
+    # execute ldap search operation
+    #
+    # for possible ldap options see Net::LDAP#search
+    #
+    def search(options = {})
+      reset_errors
+      options.symbolize_keys!
+      begin
+	result = connection.search(options)
+	add_error(operation_error)
+      rescue => e
+	result = []
+	add_error(e.message)
+      end
+      result
+    end
+
+    # returns last ldap operation error, if any
+    #
+    def operation_error
+      (connection.get_operation_result.code == 0) ? nil : connection.get_operation_result
+    end
+ 
+  private
+    attr_reader :connection
+
+    def add_error(message)
+      @errors << message
+    end
+
+    def reset_errors
+      @errors = []
+    end
+
+    def connected?
+      !!@connected
+    end
+
+    def connection(options ={})
+      return @connection if @connected
+      @connected = false
+      reset_errors
+      options.symbolize_keys!
+      @connection ||= Net::LDAP.new(options.fetch(:ldap_options))
+      if options.fetch(:bind, true)
+	begin
+	  Timeout::timeout(Wobaduser.timeout) { 
+	    if @connection.bind
+	      @connected = true
+	    else
+              add_error(operation_error)
+	    end
+	  }
+        rescue Timeout::Error => e
+          add_error("Timeout: could not bind to server within #{Wobaduser.timeout} seconds")
+        rescue Net::LDAP::Error => e
+          add_error(e.message)
+        end
+      end
+      @connection
+    end
+
+  end
+end

data/lib/wobaduser/user.rb

@@ -0,0 +1,72 @@
+module Wobaduser
+  class User < Base
+
+    ########################################################################
+    # ATTR_SV is for single valued attributes only. Generated readers will
+    # convert the value to a string before returning or calling your Proc.
+
+    ATTR_SV = {
+      # method name         ldap attribute
+      :username           => :userprincipalname,
+      :userprincipalname  => :userprincipalname,
+      :givenname          => :givenname,
+      :sn                 => :sn,
+      :cn                 => :cn,
+      :dn                 => :dn,
+      :displayname        => :displayname,
+      :mail               => :mail,
+      :title              => :title,
+      :telephonenumber    => :telephonenumber,
+      :facsimiletelephonenumber => :facsimiletelephonenumber,
+      :mobile             => :mobile,
+      :description        => :description,
+      :department         => :department,
+      :company            => :company,
+      :postalcode         => :postalcode,
+      :l                  => :l,
+      :streetaddress      => :streetaddress,
+      :samaccountname     => :samaccountname,
+      :primarygroupid     => :primarygroupid,
+      :guid               => [ :objectguid, Proc.new {|p| Base64.encode64(p).chomp } ],
+      :useraccountcontrol => :useraccountcontrol,
+      :is_valid? => [ :useraccountcontrol, Proc.new {|c| (c.to_i & 2) == 0 } ],
+    }
+
+    # ATTR_MV is for multi-valued attributes. Generated readers will always
+    # return an array.
+
+    ATTR_MV = {
+      # method name         ldap attribute
+      :members     => :member,
+      :objectclass => :objectclass,
+      :groups      => [ :memberof,
+                      # Get the simplified name of first-level groups.
+                      # TODO: Handle escaped special characters
+                      Proc.new {|g| g.sub(/.*?CN=(.*?),.*/, '\1')} ],
+      # :mailaliases => [ :proxyAddresses, Proc.new{|p| p.lowercase.gsub(/\Asmtp:/,'')}]
+      :mailaliases => [ :proxyaddresses, Proc.new {|p|
+                                           p = p.downcase
+                                           next unless p=~ /\Asmtp:/
+                                           p.gsub(/\Asmtp:/, '')
+                                         }],
+    }
+    #
+    ########################################################################
+
+    def filter(valid = false)
+      filter = Net::LDAP::Filter.eq('objectClass', 'user')
+      if valid
+        filter & ~(Net::LDAP::Filter.ex('UserAccountControl:1.2.840.113556.1.4.803', 2))
+      else
+        filter
+      end
+    end
+
+    def all_groups
+      filter = Net::LDAP::Filter.present("cn") & Net::LDAP::Filter.eq("objectClass", "group") &
+         Net::LDAP::Filter.ex("member:1.2.840.113556.1.4.1941", @entry.dn)
+      @ldap.search(filter: filter, attributes: ['cn']).map(&:cn).flatten.map(&:as_utf8)
+    end
+  end
+end
+

data/lib/wobaduser/version.rb

@@ -0,0 +1,4 @@
+module Wobaduser
+  VERSION = "1.0.0"
+  RELEASEDATE = "2018-07-21"
+end

data/spec/.env

@@ -0,0 +1,15 @@
+LDAP_HOST=
+LDAP_PORT=
+LDAP_BASE=
+LDAP_USER=
+LDAP_PASSWD=
+# SN must match UPN2 & UPN3
+# GIVENNAME must match UPN2 & UPN3
+# EMAIL must match UPN2
+USERPRINCIPALNAME=
+USERPRINCIPALNAME2=
+USERPRINCIPALNAME3=
+LDAP_SEARCH_SN=
+LDAP_SEARCH_GIVENNAME=
+LDAP_SEARCH_EMAIL=
+

data/spec/ldap_setup_spec.rb

@@ -0,0 +1,78 @@
+require 'timeout'
+require 'spec_helper'
+
+describe 'LdapSetup' do
+  context "with dummy options" do
+   let(:ldap_options) {{ "host" => '127.0.0.1', "base" => 'dc=example,dc=com', :port => 3268}}
+   let(:ldap) { Wobaduser::LDAP.new(ldap_options: ldap_options, bind: false) }
+   let(:filter) { Net::LDAP::Filter.eq("userprincipalname", "doesnotexist") }
+
+    it "set ldap options as symbols" do
+      expect(ldap.ldap_options).to be_a_kind_of Hash
+      opts = ldap.ldap_options
+      expect(opts).to include(:host, :base, :port)
+      expect(opts).not_to include("host", "base", "port")
+    end
+  
+    it { expect(ldap).to respond_to(:search) }
+    it { expect(ldap).to respond_to(:errors) }
+    it { expect(ldap).not_to respond_to(:connection) }
+    it { expect(ldap).not_to respond_to(:connected?) }
+
+    it "ldap search doesn't raise an error" do
+      expect{ 
+        ldap.search(filter: filter) 
+      }.not_to raise_error
+    end
+
+    it "ldap search delivers some errors" do
+      ldap.search(filter: filter)
+      expect(ldap.errors.any?).to be_truthy
+    end
+    
+    it "connect to a existing host without ldap server should get connection refused" do
+      ldap = nil
+      Wobaduser.timeout = 2
+      expect {
+        ldap = Wobaduser::LDAP.new(ldap_options: ldap_options, bind: true)
+      }.not_to raise_error
+      expect(ldap.errors.any?).to be_truthy
+      expect(ldap.errors.join(" ")).to match /Connection refused/
+    end
+
+    it "connect to a nonexistent host should timeout" do
+      Wobaduser.timeout = 2
+      ldap_options['host'] = '1.2.3.4'
+      ldap = Wobaduser::LDAP.new(ldap_options: ldap_options, bind: true)
+      expect(ldap.errors.join(" ")).to match /Timeout: could not bind to server/
+    end
+  end
+
+  context "with real environment" do
+    let(:ldap_options) { {
+        host: ENV['LDAP_HOST'], 
+        base: ENV['LDAP_BASE'],
+  	port: ENV['LDAP_PORT'],
+  	auth: {
+    	  method: :simple,
+    	  username: ENV['LDAP_USER'],
+    	  password: ENV['LDAP_PASSWD'],
+  	}
+      } }
+    let(:ldap) { Wobaduser::LDAP.new(ldap_options: ldap_options, bind: true) }
+
+    it "Wobaduser::LDAP should delegate search" do
+      expect(ldap).to respond_to(:search)
+    end
+
+    it "search should return Net::LDAP::Entries" do
+      filter = Net::LDAP::Filter.eq("userprincipalname", ENV['USERPRINCIPALNAME'])
+      entry = ldap.search(filter: filter).first
+      expect(ldap.errors.any?).to be_falsey
+      expect(entry).to be_a_kind_of Net::LDAP::Entry
+      expect(entry).to respond_to(:userprincipalname)
+      expect(entry.userprincipalname).to include(ENV['USERPRINCIPALNAME'])
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,26 @@
+require 'bundler/setup'
+Bundler.setup
+
+require 'wobaduser'
+require 'dotenv'
+
+Dotenv.load( File.expand_path(__FILE__ + '/../.localenv'),
+              File.expand_path(__FILE__ + '/../.env'))
+
+RSpec.configure do |config|
+  config.run_all_when_everything_filtered = true
+  # config.filter_run :focus
+  config.mock_framework = :rspec
+
+  config.around(:each) do |example|
+    Timeout::timeout(Wobaduser.timeout + 1) {
+      example.run
+    }
+  end
+
+  # 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/user_spec.rb

@@ -0,0 +1,126 @@
+require 'timeout'
+require 'spec_helper'
+
+describe 'User' do
+  context "with different options on #new" do
+    let(:ldap_options) {{"host" => '127.0.0.1', "base" => 'dc=example,dc=com', :port => 3268}}
+    let(:ldap)  { Wobaduser::LDAP.new(ldap_options: ldap_options) }
+    let(:entry) { instance_double("Net::LDAP::Entry") }
+    let(:filter) { Net::LDAP::Filter.eq("userprincipalname", "doesnotexist") }
+
+    it ":entry does not raise an ArgumentError" do
+      expect {
+        Wobaduser::User.new(entry: entry)
+      }.not_to raise_error
+    end
+
+    it ":ldap + :filter does not raise an ArgumentError" do
+      expect {
+        Wobaduser::User.new(ldap: ldap, filter: filter)
+      }.not_to raise_error
+    end
+
+    [:ldap, :filter, :ldap_options].each do |option|
+      it ":entry and #{option} raises an ArgumentError" do
+        expect {
+          Wobaduser::User.new(entry: entry, option => nil)
+        }.to raise_error(ArgumentError)
+      end
+    end
+  end
+
+  context "with dummy options" do
+    let(:ldap_options) {{"host" => '127.0.0.1', "base" => 'dc=example,dc=com', :port => 3268}}
+    let(:ldap) { Wobaduser::LDAP.new(ldap_options: ldap_options, bind: false) }
+    let(:user) { Wobaduser::User.new(ldap: ldap, filter: filter) }
+    let(:filter) { Net::LDAP::Filter.eq("userprincipalname", "doesnotexist") }
+
+    it { expect(ldap.errors.any?).to be_falsey }
+
+    it { expect { user }.not_to raise_error }
+    it { expect(user.errors.any?).to be_truthy }
+  end
+
+  context "with real environment" do
+    let(:ldap_options) {{
+        host: ENV['LDAP_HOST'], 
+        base: ENV['LDAP_BASE'],
+  	port: ENV['LDAP_PORT'],
+  	auth: {
+    	  method: :simple,
+    	  username: ENV['LDAP_USER'],
+    	  password: ENV['LDAP_PASSWD'],
+  	}
+      }}
+    let(:ldap) {Wobaduser::LDAP.new(ldap_options: ldap_options, bind: true)}
+    
+    context "and valid USERPRINCIPALNAME" do
+      let(:filter) {Net::LDAP::Filter.eq("userprincipalname", ENV['USERPRINCIPALNAME'])}
+
+      it "valid user should respond to various attribute methods" do
+	user = Wobaduser::User.new(ldap: ldap, filter: filter)
+	expect(user.valid?).to be_truthy
+	expect(user).to respond_to(:userprincipalname)
+	expect(user.userprincipalname).to include(ENV['USERPRINCIPALNAME'])
+	Wobaduser::User::ATTR_SV.each do |key,value|
+	  expect(user.send(key)).to be_a_kind_of String unless key == :is_valid?
+	end
+	Wobaduser::User::ATTR_MV.each do |key,value|
+	  expect(user.send(key)).to be_a_kind_of Array
+	end
+      end
+    end
+
+    context "and invalid USERPRINCIPALNAME" do
+      let(:filter) {Net::LDAP::Filter.eq("userprincipalname", "doesnotexist")}
+
+      it "valid user should respond to various attribute methods" do
+	user = Wobaduser::User.new(ldap: ldap, filter: filter)
+	expect(user.valid?).to be_falsey
+      end
+    end
+
+    describe "::search" do
+      let(:entries) { Wobaduser::User.search(ldap: ldap, filter: filter) }
+      let(:users)   { entries.entries }
+
+      context "search for sn" do
+        let(:filter) {Net::LDAP::Filter.eq("sn", "#{ENV['LDAP_SEARCH_SN']}*")}
+
+        it { expect(entries.success?).to be_truthy }
+	it { expect(users).to be_a_kind_of Array }
+	it { expect(users.map {|u| u.userprincipalname}).to include( 
+	     ENV['USERPRINCIPALNAME3'], ENV['USERPRINCIPALNAME2']) }
+      end
+
+      context "search for givenname" do
+        let(:filter) {Net::LDAP::Filter.eq("givenname", ENV['LDAP_SEARCH_GIVENNAME'])}
+
+        it { expect(entries.success?).to be_truthy }
+	it { expect(users).to be_a_kind_of Array }
+	it { expect(users.map {|u| u.userprincipalname}).to include( 
+	     ENV['USERPRINCIPALNAME3'], ENV['USERPRINCIPALNAME2']) }
+      end
+
+      context "search for mail" do
+        let(:filter) {Net::LDAP::Filter.eq("mail", ENV['LDAP_SEARCH_EMAIL'])}
+
+        it { expect(entries.success?).to be_truthy }
+	it { expect(users).to be_a_kind_of Array }
+	it { expect(users.map {|u| u.userprincipalname}).to include( 
+	     ENV['USERPRINCIPALNAME2']) }
+      end
+
+      context "with invalid filter" do
+        let(:filter) {"bla"}
+        let(:entries) { Wobaduser::User.search(ldap: ldap, filter: filter) }
+
+        it "raises a FilterSyntaxInvalidError" do
+          expect { 
+            entries.success?
+          }.to raise_error(Net::LDAP::FilterSyntaxInvalidError)
+        end
+      end
+    end
+  end
+end

data/wobaduser.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'wobaduser/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "wobaduser"
+  spec.version       = Wobaduser::VERSION
+  spec.authors       = ["Wolfgang Barth"]
+  spec.email         = ["wob@swobspace.net"]
+  spec.summary       = %q{Lightweight Active Directory LDAP read access}
+  spec.description   = %q{Lightweight Active Directory LDAP read access}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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_dependency "net-ldap"
+  spec.add_dependency "activesupport"
+  spec.add_dependency "immutable-struct"
+
+  spec.add_development_dependency "bundler", "> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "dotenv"
+end

metadata

@@ -0,0 +1,165 @@
+--- !ruby/object:Gem::Specification
+name: wobaduser
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Wolfgang Barth
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-07-21 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: net-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: activesupport
+  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: immutable-struct
+  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: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">"
+      - !ruby/object:Gem::Version
+        version: '1.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  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'
+- !ruby/object:Gem::Dependency
+  name: dotenv
+  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: Lightweight Active Directory LDAP read access
+email:
+- wob@swobspace.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/string_addons.rb
+- lib/wobaduser.rb
+- lib/wobaduser/base.rb
+- lib/wobaduser/ldap.rb
+- lib/wobaduser/user.rb
+- lib/wobaduser/version.rb
+- spec/.env
+- spec/ldap_setup_spec.rb
+- spec/spec_helper.rb
+- spec/user_spec.rb
+- utils/test.rb
+- utils/test2.rb
+- wobaduser.gemspec
+homepage: ''
+licenses:
+- MIT
+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.6.14.1
+signing_key: 
+specification_version: 4
+summary: Lightweight Active Directory LDAP read access
+test_files:
+- spec/.env
+- spec/ldap_setup_spec.rb
+- spec/spec_helper.rb
+- spec/user_spec.rb