Adding values to array in recursive method - ruby

Question

Method: get_users_in_groups(groupname)
Purpose: Gets all members from group and any nested groups' members.
English translation of method:
get group information
if group has members,
add members to users[]
end
If group has nested_groups,
for nested_group in nested_groups
get nested_groupname
get_users_in_groups(nested_groupname)
end
end
Currently I pass the users array in the method attributes. However, this doesn't seem like the proper way to access an array in a recursive method.
What is the best way to add members to the users array through my recursive method?
I think I might have found a solution.
users = []
get group information
if group has members,
users.concat( members[] )
end
If group has nested_groups,
for nested_group in nested_groups
get nested_groupname
users.concat( get_users_in_groups(nested_groupname) )
end
end
users.uniq
Is this the best way to do this?
Sorry about that I meant to include one!
isc-staff
nested-groups: isc-admins, isc-teachers, isc-paras
members: none
isc-admins
nested-groups: none
members: adminone, admintwo
isc-teachers
nested-groups: sped-teachers
members: teacherone, teachertwo
isc-paras
nested-groups: none
members: paraone, paratwo
sped-teachers
nested-groups: none
members: spedteacherone, spedteachertwo
So my method looks up isc-staff, sees that it has isc-admins, isc-teachers, and isc-paras but no members, it needs to run itself on isc-admins, isc-teachers, and isc-paras.
When it runs on isc-admins it should add the members to users[]
When it runs on isc-teachers it should add the members to users[] and run itself through sped-teachers
This information isn't stored in an array, it has to be pulled from LDAP.
Is that enough information?
The structure would look something similar to
{
group_name: 'isc-staff',
nested_groups: [
{
group_name: 'isc-admins',
members: ['adminone', 'admintwo']
},
{
group_name: 'isc-teachers',
members: ['teacherone', 'teachertwo'],
nested_groups: [
{
group_name: 'sped-teachers',
members: ['spedteacherone']
}
]
},
{
group_name: 'isc-paras',
members: ['paraone', 'paratwo']
}
]
}
Result should be:
['adminone','admintwo','teacherone','teachertwo','spedteacherone','paraone','paratwo']

Answer 1

Assuming your data structure is a hash with symbol keys, a simple recursive function does the trick:
def all_group_members group
members = []
members.concat group[:members] if group[:members]
if group[:nested_groups]
group[:nested_groups].each { |g| members.concat all_group_members(g) }
end
members
end

Answer 2

My solution is quite general. Your structure can be an array or hash, recursively containing arrays, hashes and literals to any depth. I have assumed the values you want are strings within arrays, and that all arrays contain no strings or only strings (though those containing no strings may contain nested arrays of strings, which will be found).
Code
def getem(e,a=[])
case e
when Array
case e.first
when String
e.each { |f| a << f }
else
e.each do |f|
case f
when Array, Hash
getem(f,a)
end
end
end
when Hash
e.each { |_,v| getem(v,a) }
end
a
end
Example
h = {
group_name: 'isc-staff',
nested_groups:
[
{
group_name: 'isc-admins',
members: ['adminone', 'admintwo']
},
{
group_name: 'isc-teachers',
members: ['teacherone', 'teachertwo'],
nested_groups:
[{
group_name: 'sped-teachers',
members: ['spedteacherone']
}]
},
{
group_name: 'isc-paras',
members: ['paraone', 'paratwo']
}
]
}
getem(h)
#=> ["adminone", "admintwo", "teacherone", "teachertwo",
# "spedteacherone", "paraone", "paratwo"]
(Notice that you made a couple of small mistakes in your example hash.)
Explanation
getem is called when e is an array or a hash. The return value is the array a, which defaults to an empty array when getem is first called.
we use a case statement to test for an object's class. This works because case uses Object#===, rather than ==, for determining true or false.
if the first argument of getem is an array, we see if the first element is a string. If it is, we assume all elements are strings, and add them to the array a. Otherwise, we recursively call getem for each element that is an array or a hash.
if the first argument of getem is a hash, we recursively call getem for each value that is an array or a hash. (Since we do not use the hash keys within the block, we can write |_v| rather than |k,v|).

Answer 3

From what I've learned about recursive queries over the past few days, I came up with this method. Does this work?
def self.get_users_in_group(groupname)
users = []
if exists?(groupname)
params = [
"GroupMembership",
"NestedGroups"
]
DSQuery.generate_dscl("read","/Groups/#{groupname}",params)
output = DSQuery.run
# Add members of group to users array.
if output.has_key?('dsAttrTypeStandard:GroupMembership')
users.concat(output['dsAttrTypeStandard:GroupMembership'])
end
# if group contains nested groups,
# get_users_in_group for each nested group and add to users array.
if output.has_key?('dsAttrTypeStandard:NestedGroups')
output['dsAttrTypeStandard:NestedGroups'].each do |generate_dscldUID|
results = find('GeneratedUID',generate_dscldUID)
if !results.empty?
result = results[0]
length_of_nested_group_name = result.index("\t") - "\t".length
nested_group_name = result.slice(0..length_of_nested_group_name)
users.concat( get_users_in_group(nested_group_name) )
end
end
end
end
users.uniq
end