Module: RoleAuthorization::Roles::Manager::InstanceMethods

Included in:
RoleAuthorization::Roles::Manager
Defined in:
lib/role_authorization/roles/manager.rb

Instance Method Summary collapse

Instance Method Details

#any(new_scope = nil) ⇒ Object 



59
60
61
62
63
64
65
66
67
68
 
# File 'lib/role_authorization/roles/manager.rb', line 59

def any(new_scope = nil)
  case new_scope
  when nil
    [global_roles, object_roles.values].flatten
  when :global
    global_roles
  else
    object_roles[new_scope]
  end
end

#creation_rules(rules) ⇒ Object 



45
46
47
48
49
 
# File 'lib/role_authorization/roles/manager.rb', line 45

def creation_rules(rules)
  rules.each_pair do |key, allowed_roles|
    @creations[key] = allowed_roles.flatten.uniq
  end
end

#group(groups) ⇒ Object 



51
52
53
 
# File 'lib/role_authorization/roles/manager.rb', line 51

def group(groups)
  @group_definitions = groups
end

#nickname(nicknames) ⇒ Object 



55
56
57
 
# File 'lib/role_authorization/roles/manager.rb', line 55

def nickname(nicknames)
  @nicknames = nicknames
end

#persist! ⇒ Object

make sure our defined roles are in the database remove any roles taken out



72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
 
# File 'lib/role_authorization/roles/manager.rb', line 72

def persist!
  return if klass.nil?
  return unless klass.new.respond_to?(:nickname)

  persisted_roles = klass.all.inject({}) {|hash, record| hash[record.name.to_sym] = record; hash}

  [global_roles, object_roles.values].flatten.map do |role_name|
    if persisted_roles.delete(role_name).nil?
      klass.create(:name => role_name.to_s, :nickname => nicknames[role_name].to_s)
    end
  end

  # if we have persisted roles left we delete them
  persisted_roles.values.map(&:destroy)
end

#role(role_name) ⇒ Object 



22
23
24
25
 
# File 'lib/role_authorization/roles/manager.rb', line 22

def role(role_name)
  @_role ||= {}
  @_role[role_name] ||= klass.find_by_name(role_name)
end

#roles(*options) ⇒ Object 



37
38
39
40
41
42
43
 
# File 'lib/role_authorization/roles/manager.rb', line 37

def roles(*options)
  @global_roles, @object_roles = if options.last.is_a?(Hash)
                                   [options.pop, options].reverse
                                 else
                                   [options, {}]
                                 end
end

#setup(klass) ⇒ Object 



27
28
29
30
31
32
33
34
35
 
# File 'lib/role_authorization/roles/manager.rb', line 27

def setup(klass)
  @klass = klass
  klass.send(:include, RoleAuthorization::Roles::Role)

  # now that we know what class to use, create our role groups
  (@group_definitions || {}).each_pair do |group_name, roles|
    @groups[group_name.to_sym] = RoleAuthorization::Roles::RoleGroup.new(klass, roles)
  end
end