ucb_groups 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8a70a98622c14e05dc6d97321b88fa49814fe37c
+  data.tar.gz: f7a84e130fabac3db97c20f6927151eca557b66b
+SHA512:
+  metadata.gz: dbb318e65608a45bb2f15782012ab6e556592cc1102cc774198cff91402542ba9ecbc2cd87660b008b9007ae37021bc78d338050aa0679ac64d5f87f32888d4b
+  data.tar.gz: aa28f08ef4abddf05884c02a979acbf67e4312f57b19a0e65a6a42549edceba8c9ebc1d45808606f26f95c5f36fbef4dee11cb149170b5516698c23997a936f9

data/.gitignore

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

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 sahglie
+
+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,54 @@
+# UcbGroups
+
+Finds users that belong to a given ucb group
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'ucb_groups'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ucb_groups
+
+## Usage
+
+First, authenticate:
+```
+UcbGroups::LdapConn.authenticate(<username>,  <password>)
+```
+
+Then...
+
+Get list of groups in namespace:
+```
+UcbGroups::CampusGroup.find(<namespace>)
+=> [CampusGroup, CampusGroup, ...]
+```
+
+Find people in one or more groups:
+```
+finder = UcbGroups::MembershipFinder.new(<namespace>)
+people = finder.find(:groups => [grp1, grp2])
+=> [Person, Person, Person, ...]
+```
+
+Find people in groups and filter by org:
+```
+finder = UcbGroups::MembershipFinder.new(<namespace>)
+people = finder.find(:groups => [grp1, grp2], :orgs => [:JKASD])
+=> [Person, Person, Person, ...]
+```
+
+## 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 @@
+require "bundler/gem_tasks"

data/lib/ucb_groups/campus_group.rb

@@ -0,0 +1,31 @@
+module UcbGroups
+  class CampusGroup
+    attr_accessor :dn, :description, :namespace, :name
+
+    def initialize(ldap_entry)
+      @dn = ldap_entry[:dn].first.to_s
+      @description = ldap_entry[:description].first.to_s
+      @namespace, @name = parse_dn
+    end
+
+    def self.find(namespace)
+      args = {
+          :base => "ou=campus groups,dc=berkeley,dc=edu",
+          :filter => build_filter(namespace),
+          :attributes => %w(dn description name),
+      }
+      LdapConn.conn.search(args).map { |entry| CampusGroup.new(entry) }
+    end
+
+    private
+
+    # example dn: "cn=edu:berkeley:app:calmessages:faculty,ou=campus groups,dc=berkeley,dc=edu"
+    def parse_dn
+      dn.split(/:|,/)[3..4].map(&:to_s)
+    end
+
+    def self.build_filter(namespace)
+      "(&(objectclass=*)(cn=edu:berkeley:app:#{namespace}*))"
+    end
+  end
+end

data/lib/ucb_groups/ldap_conn.rb

@@ -0,0 +1,36 @@
+module UcbGroups
+  class LdapConn
+    def self.conn
+      net_ldap = ::Net::LDAP.new(auth_info)
+      net_ldap.bind || raise(BindFailedException)
+      net_ldap
+    rescue ::Net::LDAP::LdapError
+      raise(LdapBindFailedException)
+    end
+
+    def self.authenticate(username, password)
+      @username = username
+      @password = password
+    end
+
+    def self.authenticate_from_config(config_file)
+      conf = YAML.load_file(config_file)
+      @username, @password = conf['username'], conf['password']
+    end
+
+    private
+
+    def self.auth_info
+      @auth_info ||= {
+          host: "ldap.berkeley.edu",
+          auth: {
+              method: :simple,
+              username: @username,
+              password: @password,
+          },
+          port: 636,
+          encryption: { method: :simple_tls }
+      }
+    end
+  end
+end

data/lib/ucb_groups/membership_filter.rb

@@ -0,0 +1,50 @@
+module UcbGroups
+  class MembershipFilter
+    attr_accessor :namespace, :groups, :orgs
+
+    def initialize(namespace, groups, orgs)
+      @namespace = namespace
+      @groups = groups
+      @orgs = orgs
+    end
+
+    def to_s
+      @filter ||= begin
+        if groups.empty?
+          objectclass_filter & orgs_filter
+        elsif orgs.empty?
+          objectclass_filter & groups_filter
+        else
+          objectclass_filter & (groups_filter & orgs_filter)
+        end
+      end
+      @filter.to_rfc2254
+    end
+
+    private
+
+    def objectclass_filter
+      Net::LDAP::Filter.eq("objectclass", "person")
+    end
+
+    def groups_filter
+      groups.map    { |group| group_filter(group) }
+            .reduce { |accum, filter| accum.send("|", filter) }
+    end
+
+    def group_filter(group)
+      Net::LDAP::Filter.
+          eq("ismemberof",
+             "cn=edu:berkeley:app:#{self.namespace}:#{group},ou=campus groups,dc=berkeley,dc=edu")
+    end
+
+    def orgs_filter
+      @orgs.map    { |org| org_filter(org) }
+           .reduce { |accum, filter| accum.send("|", filter) }
+    end
+
+    def org_filter(org)
+      Net::LDAP::Filter.eq("berkeleyedudeptunithierarchystring", "*#{org}*")
+    end
+  end
+end

data/lib/ucb_groups/membership_finder.rb

@@ -0,0 +1,52 @@
+module UcbGroups
+  class MembershipFinder
+    attr_accessor :namespace, :groups, :orgs
+
+    def initialize(namespace)
+      @namespace = namespace
+    end
+
+    def find(*options)
+      @groups, @orgs = parse_options(options)
+
+      return [] if @groups.empty? && @orgs.empty?
+
+      ensure_valid_options
+
+      args = {
+          base: "ou=people,dc=berkeley,dc=edu",
+          filter: membership_filter,
+          attributes: Person.ldap_attributes
+      }
+
+      LdapConn.conn.search(args).map { |entry| Person.new(entry) }
+    end
+
+    private
+
+    def parse_options(options)
+      options = options.first || {}
+      groups = options.fetch(:groups, []).map(&:to_s)
+      orgs = options.fetch(:orgs, []).map(&:to_s)
+
+      [groups, orgs]
+    end
+
+    def ensure_valid_options
+      groups.each do |group|
+        unless namespace_groups.include?(group.to_s)
+          raise(InvalidCampusGroupError.new(group))
+        end
+      end
+    end
+
+    def membership_filter
+      MembershipFilter.new(namespace, groups, orgs).to_s
+    end
+
+    def namespace_groups
+      @namespace_groups ||= CampusGroup.find(namespace).map(&:name)
+    end
+  end
+end
+

data/lib/ucb_groups/monkey_patches/net_ldap_filter.rb

@@ -0,0 +1,38 @@
+# Pull request with this patch has been submitted via github.  As soon
+# as this patch is merged into ruby-net-ldap master branch we can remove
+# this monkey patch
+
+Net::LDAP::Filter::FilterParser.class_eval do
+  def parse_filter_branch(scanner)
+    scanner.scan(/\s*/)
+    if token = scanner.scan(/[-\w:.]*[\w]/)
+      scanner.scan(/\s*/)
+      if op = scanner.scan(/<=|>=|!=|:=|=/)
+        scanner.scan(/\s*/)
+        #if value = scanner.scan(/(?:[-\w*.+@=,#\$%&!'\s]|\\[a-fA-F\d]{2})+/)
+
+        # Our patch allows ':' as a valid character.
+        if value = scanner.scan(/(?:[-\w*.+@=,:#\$%&!'\s]|\\[a-fA-F\d]{2})+/)
+          # 20100313 AZ: Assumes that "(uid=george*)" is the same as
+          # "(uid=george* )". The standard doesn't specify, but I can find
+          # no examples that suggest otherwise.
+          value.strip!
+
+          case op
+            when "="
+              Net::LDAP::Filter.eq(token, value)
+            when "!="
+              Net::LDAP::Filter.ne(token, value)
+            when "<="
+              Net::LDAP::Filter.le(token, value)
+            when ">="
+              Net::LDAP::Filter.ge(token, value)
+            when ":="
+              Net::LDAP::Filter.ex(token, value)
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/ucb_groups/person.rb

@@ -0,0 +1,41 @@
+module UcbGroups
+  class Person
+    include Comparable
+
+    ATTRIBUTE_MAPPINGS = {
+        :uid => :uid,
+        :first_name => :givenname,
+        :last_name => :sn,
+        :email => :mail,
+        :orgs => :berkeleyEduPrimaryDeptUnitHierarchyString
+    }.freeze
+
+    attr_accessor *ATTRIBUTE_MAPPINGS.keys
+
+    def initialize(ldap_entry)
+      ATTRIBUTE_MAPPINGS.each do |attr, val|
+        self.send("#{attr}=", ldap_entry[val].first.to_s) if ldap_entry[val]
+      end
+    end
+
+    def full_name
+      [first_name, last_name].join(" ")
+    end
+
+    def self.ldap_attributes
+      @ldap_attributes ||= ATTRIBUTE_MAPPINGS.values.map(&:to_s)
+    end
+
+    def eql?(other_person)
+      self.hash == other_person.hash
+    end
+
+    def hash
+      self.uid.to_i
+    end
+
+    def <=>(other_person)
+      self.hash <=> other_person.hash
+    end
+  end
+end

data/lib/ucb_groups/version.rb

@@ -0,0 +1,3 @@
+module UcbGroups
+  VERSION = "0.0.2"
+end

data/lib/ucb_groups.rb

@@ -0,0 +1,36 @@
+require 'pp'
+require 'ostruct'
+require 'net-ldap'
+require 'json'
+
+require "ucb_groups/version"
+require "ucb_groups/person"
+require "ucb_groups/ldap_conn"
+require "ucb_groups/campus_group"
+require "ucb_groups/membership_filter"
+require "ucb_groups/membership_finder"
+require "ucb_groups/monkey_patches/net_ldap_filter"
+
+
+module UcbGroups
+  LdapBindFailedException = Class.new(StandardError)
+
+  class InvalidCampusGroupError < StandardError
+    def initialize(group)
+      super(group)
+    end
+  end
+
+  class InvalidFinderOptions < StandardError
+    def initialize
+      super("You must provide at least one group or one org")
+    end
+  end
+end
+
+
+if __FILE__ == $PROGRAM_NAME
+  finder = UcbGroups::MembershipFinder.new("calmessages")
+  people = finder.find(:groups => ["it-staff"], :orgs => ["JKASD"])
+  pp people
+end

data/spec/integration/calmsgs_groups_spec.rb

@@ -0,0 +1,127 @@
+require 'rest-client'
+require_relative "../spec_helper"
+require 'set'
+
+#groups = UcbGroups::CampusGroup.find(:calmessages)
+#pp groups.map(&:name).sort
+
+
+def assert_matching_group(group)
+  @finder ||= UcbGroups::MembershipFinder.new(:calmessages)
+  grouper_uids = @finder.find(:groups => [group]).map(&:uid).sort
+  calmsgs_uids = calmsgs_group_uids(group)
+
+  #if calmsgs_uids.length != grouper_uids.length
+    puts "calmsgs: #{calmsgs_uids.length}, grouper: #{grouper_uids.length}"
+    puts "Only In Calmsgs: #{calmsgs_uids - grouper_uids}\nOnly in Grouper: #{grouper_uids - calmsgs_uids}"
+    grouper_uids.length.should eql(calmsgs_uids.length)
+  #end
+
+  calmsgs_uids.should eql(grouper_uids)
+end
+
+def calmsgs_group_uids(group)
+  uids = RestClient.get("localhost:3000/api/groups/#{group}.json")
+  JSON.parse(uids).map(&:to_s).sort
+end
+
+
+describe "Calmsgs Groups Compatibility" do
+  it "academic-senate-faculty" do
+    # fails but close enough
+    assert_matching_group("academic-senate-faculty")
+  end
+
+  it "deans" do
+    # fails but close enough
+    assert_matching_group("deans")
+  end
+
+  it "dept-admin" do
+    # fails because ldap does not keep emptititlecode around for expired people and caldap does (close enough)
+    assert_matching_group("dept-admin")
+  end
+
+  it "dept-chairs" do
+    # fails but close enough
+    assert_matching_group("dept-chairs")
+  end
+
+  it "directors" do
+    assert_matching_group("directors")
+  end
+
+  it "emeriti" do
+    assert_matching_group("emeriti")
+  end
+
+  it "faculty" do
+    # fails because calmsgs is grabbing people that it shouldn't.  In many instances calmsgs
+    # is grabbing staff that have no academic affiliation (close enough)
+    assert_matching_group("faculty")
+  end
+
+  it "it-staff" do
+    # fails because calmsgs it grabbing retired or expired it-staff (close enough)
+    assert_matching_group("it-staff")
+  end
+
+  it "staff" do
+    # fails but close enough
+    assert_matching_group("staff")
+  end
+
+  it "students" do
+    # fails but close enough
+    assert_matching_group("students")
+  end
+
+  it "managers" do
+    assert_matching_group("managers") # fails but close enough
+  end
+
+  it "supervisors" do
+    assert_matching_group("supervisors") # fails but close enough
+  end
+
+  it "affiliates" do
+    assert_matching_group("affiliates") # fails
+  end
+
+  it "ucop" do
+    # fails but close enough
+    assert_matching_group("ucop")
+  end
+
+  it "graduate-students" do
+    # no calmsgs group
+    # assert_matching_group("graduate-students")
+  end
+
+  it "advisors" do
+    # no calmsgs group
+    # assert_matching_group("advisors")
+  end
+
+  it "gsis" do
+    # no calmsgs group
+    # assert_matching_group("gsis")
+  end
+
+  it "gsrs" do
+    # no calmsgs group
+    # assert_matching_group("gsrs")
+  end
+
+  it "instructors" do
+    # no calmsgs group
+    #assert_matching_group("instructors")
+  end
+
+  it "undergrad-students" do
+    # no calmsgs group
+    # assert_matching_group("undergrad-students")
+  end
+end
+
+

data/spec/spec_helper.rb

@@ -0,0 +1,7 @@
+require_relative '../lib/ucb_groups'
+require 'yaml'
+
+RSpec.configure do |config|
+  ldap_yml = File.expand_path(File.dirname("#{__FILE__}") + "/../ldap.yml")
+  UcbGroups::LdapConn.authenticate_from_config(ldap_yml)
+end

data/spec/ucb_groups/campus_group_spec.rb

@@ -0,0 +1,25 @@
+require_relative "../spec_helper"
+
+
+describe "CampusGroup" do
+  let(:entry) do
+    {
+        :dn => ["cn=edu:berkeley:app:calmessages:faculty,ou=campus groups,dc=berkeley,dc=edu"],
+        :description => ["Instructors"]
+    }
+  end
+
+  it "Finds Campus Groups" do
+    groups = UcbGroups::CampusGroup.find(:calmessages)
+    groups.should_not be_empty
+  end
+
+  it "initializes an entry" do
+    group = UcbGroups::CampusGroup.new(entry)
+
+    group.dn.should eql(entry[:dn].first)
+    group.description.should eql(entry[:description].first)
+    group.namespace.should eql("calmessages")
+    group.name.should eql("faculty")
+  end
+end

data/spec/ucb_groups/membership_filter_spec.rb

@@ -0,0 +1,54 @@
+require_relative "../spec_helper"
+
+
+describe "MembershipFilter" do
+  let(:finder) { UcbGroups::MembershipFilter.new(namespace, groups, orgs) }
+
+  it "creates groups filter" do
+    filter = UcbGroups::MembershipFilter.new(:calmessages, [:deans], []).to_s
+    filter_str = "(&(objectclass=person)" +
+                    "(ismemberof=cn=edu:berkeley:app:calmessages:deans,ou=campus groups,dc=berkeley,dc=edu))"
+    filter.should eql(filter_str)
+
+    filter = UcbGroups::MembershipFilter.new(:calmessages, [:deans, :instructors], []).to_s
+    filter_str = "(&(objectclass=person)" +
+                    "(|(ismemberof=cn=edu:berkeley:app:calmessages:deans,ou=campus groups,dc=berkeley,dc=edu)" +
+                      "(ismemberof=cn=edu:berkeley:app:calmessages:instructors,ou=campus groups,dc=berkeley,dc=edu)))"
+    filter.should eql(filter_str)
+  end
+
+  it "creates orgs filter" do
+    filter = UcbGroups::MembershipFilter.new(:calmessages, [], ["JKASD"]).to_s
+    filter_str = "(&(objectclass=person)" +
+                   "(berkeleyedudeptunithierarchystring=*JKASD*))"
+    filter.should eql(filter_str)
+
+    filter = UcbGroups::MembershipFilter.new(:calmessages, [], ["JKASD", "JJCNS"]).to_s
+    filter_str = "(&(objectclass=person)" +
+                   "(|(berkeleyedudeptunithierarchystring=*JKASD*)" +
+                     "(berkeleyedudeptunithierarchystring=*JJCNS*)))"
+    filter.should eql(filter_str)
+  end
+
+  it "creates groups and orgs filter" do
+    filter = UcbGroups::MembershipFilter.new(:calmessages, [:deans], ["JKASD"]).to_s
+    filter_str = "(&(objectclass=person)" +
+                   "(&(ismemberof=cn=edu:berkeley:app:calmessages:deans,ou=campus groups,dc=berkeley,dc=edu)" +
+                     "(berkeleyedudeptunithierarchystring=*JKASD*)))"
+    filter.should eql(filter_str)
+
+    filter = UcbGroups::MembershipFilter.new(:calmessages, [:deans, :instructors], ["JKASD"]).to_s
+    filter_str = "(&(objectclass=person)" +
+                   "(&(|(ismemberof=cn=edu:berkeley:app:calmessages:deans,ou=campus groups,dc=berkeley,dc=edu)" +
+                       "(ismemberof=cn=edu:berkeley:app:calmessages:instructors,ou=campus groups,dc=berkeley,dc=edu))" +
+                     "(berkeleyedudeptunithierarchystring=*JKASD*)))"
+    filter.should eql(filter_str)
+
+    filter = UcbGroups::MembershipFilter.new(:calmessages, [:deans, :instructors], ["JKASD", "JJCNS"]).to_s
+    filter_str = "(&(objectclass=person)" +
+                   "(&(|(ismemberof=cn=edu:berkeley:app:calmessages:deans,ou=campus groups,dc=berkeley,dc=edu)" +
+                       "(ismemberof=cn=edu:berkeley:app:calmessages:instructors,ou=campus groups,dc=berkeley,dc=edu))" +
+                     "(|(berkeleyedudeptunithierarchystring=*JKASD*)(berkeleyedudeptunithierarchystring=*JJCNS*))))"
+    filter.should eql(filter_str)
+  end
+end

data/spec/ucb_groups/membership_finder_spec.rb

@@ -0,0 +1,52 @@
+require_relative "../spec_helper"
+
+
+describe "MembershipFinder" do
+  let(:finder) { UcbGroups::MembershipFinder.new(:calmessages) }
+
+  context "find options" do
+    it "recognizes if groups are invalid" do
+      err = UcbGroups::InvalidCampusGroupError
+      expect { finder.find(:groups => [:invalid_group]) }.to raise_error(err)
+      expect { finder.find(:groups => [:deans, :invalid_group]) }.to raise_error(err)
+    end
+
+    it "returns no results if :group and :orgs are both empty" do
+      finder.find(:groups => [], :orgs => []).should be_empty
+    end
+  end
+
+  context "Finding by group" do
+    it "finds users in a single group" do
+      finder.find(:groups => [:deans]).should_not be_empty
+    end
+
+    it "finds users in a multiple groups" do
+      finder.find(:groups => [:deans, :instructors]).should_not be_empty
+    end
+  end
+
+  context "Finding by org" do
+    it "finds users beneath a single org" do
+      finder.find(:orgs => [:JKASD]).should_not be_empty
+    end
+
+    it "finds users beneath any of the provided orgs" do
+      jkasd_people = finder.find(:orgs => [:JKASD])
+      jkasd_jjcns_people = finder.find(:orgs => [:JKASD, :JJCNS])
+
+      (jkasd_people.length < jkasd_jjcns_people.length).should be_true
+    end
+  end
+
+  context "Finding by group and org" do
+    it "finds users in a single group and org" do
+      campus_it_staff = finder.find(:groups => ["it-staff"])
+      ist_it_staff = finder.find(:groups => ["it-staff"], :orgs => [:VRIST])
+
+      campus_it_staff.should_not be_empty
+      ist_it_staff.should_not be_empty
+      (ist_it_staff.length < campus_it_staff.length).should be_true
+    end
+  end
+end

data/spec/ucb_groups_spec.rb

@@ -0,0 +1,4 @@
+require_relative "spec_helper"
+
+describe UcbGroups do
+end

data/ucb_groups.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ucb_groups/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ucb_groups"
+  spec.version       = UcbGroups::VERSION
+  spec.authors       = ["sahglie"]
+  spec.email         = ["sahglie@gmail.com"]
+  spec.description   = %q{Finds users that belong to a given ucb group}
+  spec.summary       = %q{Finds users that belong to a given ucb group}
+  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_development_dependency "rspec", "~> 2.7"
+  spec.add_development_dependency "rest-client"
+  spec.add_development_dependency "json"
+
+  spec.add_runtime_dependency "ucb_ldap", "2.0.0.pre5"
+  spec.add_runtime_dependency "net-ldap", "0.2.2"
+end

metadata

@@ -0,0 +1,169 @@
+--- !ruby/object:Gem::Specification
+name: ucb_groups
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- sahglie
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-09-18 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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: '2.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.7'
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  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: json
+  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: ucb_ldap
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.0.0.pre5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.0.0.pre5
+- !ruby/object:Gem::Dependency
+  name: net-ldap
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.2.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.2.2
+description: Finds users that belong to a given ucb group
+email:
+- sahglie@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/ucb_groups.rb
+- lib/ucb_groups/campus_group.rb
+- lib/ucb_groups/ldap_conn.rb
+- lib/ucb_groups/membership_filter.rb
+- lib/ucb_groups/membership_finder.rb
+- lib/ucb_groups/monkey_patches/net_ldap_filter.rb
+- lib/ucb_groups/person.rb
+- lib/ucb_groups/version.rb
+- spec/integration/calmsgs_groups_spec.rb
+- spec/spec_helper.rb
+- spec/ucb_groups/campus_group_spec.rb
+- spec/ucb_groups/membership_filter_spec.rb
+- spec/ucb_groups/membership_finder_spec.rb
+- spec/ucb_groups_spec.rb
+- ucb_groups.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.0.3
+signing_key: 
+specification_version: 4
+summary: Finds users that belong to a given ucb group
+test_files:
+- spec/integration/calmsgs_groups_spec.rb
+- spec/spec_helper.rb
+- spec/ucb_groups/campus_group_spec.rb
+- spec/ucb_groups/membership_filter_spec.rb
+- spec/ucb_groups/membership_finder_spec.rb
+- spec/ucb_groups_spec.rb
+has_rdoc: