Class: WizAcl::Acl

Inherits:
Object
  • Object
show all
Defined in:
lib/wizdog/acl/acl.rb

Constant Summary collapse

@@serialize_path = 
File.join(File.dirname(__FILE__),"..","..","acl.yml")

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize ⇒ Acl

Returns a new instance of Acl.



7
8
9
10
11
12
13
14
 
# File 'lib/wizdog/acl/acl.rb', line 7

def initialize
    @entries = []
    @entries << WizAcl::Entry.new("*", "*").deny("*")
    #{aco_id => {:instance => aro, :parents => {prent_id => parent}, :children => {aro_id => aro}}}
    @aros = {}
    #{:instance => aco, :parent => aco_parent, :children => {}}
    @acos = {}
end

Instance Attribute Details

#entries ⇒ Object

Returns the value of attribute entries.



6
7
8
 
# File 'lib/wizdog/acl/acl.rb', line 6

def entries
  @entries
end

Class Method Details

.authorize(&block) ⇒ Object 



21
22
23
 
# File 'lib/wizdog/acl/acl.rb', line 21

def self.authorize(&block)
  block.call(instance)
end

.instance ⇒ Object 



16
17
18
19
 
# File 'lib/wizdog/acl/acl.rb', line 16

def self.instance
    #unserialize
    @@__acl__ ||=new
end

.serialize ⇒ Object 



29
30
31
32
33
 
# File 'lib/wizdog/acl/acl.rb', line 29

def self.serialize
  File.open(@@serialize_path,"w") do |io|
     YAML.dump(@@__acl__, io)
  end
end

.serialize_path=(path) ⇒ Object 



35
36
37
 
# File 'lib/wizdog/acl/acl.rb', line 35

def self.serialize_path=(path)
  @@serialize_path = path
end

.unserialize ⇒ Object 



25
26
27
 
# File 'lib/wizdog/acl/acl.rb', line 25

def self.unserialize
  YAML.load_file(@@serialize_path)
end

Instance Method Details

#add_aco(aco, parents = "*") ⇒ Object 



53
54
55
56
57
58
59
60
61
62
63
64
65
 
# File 'lib/wizdog/acl/acl.rb', line 53

def add_aco(aco, parents = "*")
  aco = Aco.new(aco) unless aco.respond_to?(:aco_id)

  @acos[aco.aco_id] = {:instance => aco, :parents =>{}, :children =>{}}

  parents = [parents] unless parents.is_a?(Array)
  parents.each do |parent|
    parent = Aco.new(parent) unless parent.respond_to?(:aco_id)
    @acos[parent.aco_id] = @acos[parent.aco_id] || {:instance => parent,:parents =>{}, :children =>{}}
    @acos[aco.aco_id][:parents][parent.aco_id] = @acos[parent.aco_id][:instance]
    @acos[parent.aco_id][:children][aco.aco_id] = @acos[aco.aco_id][:instance]
  end
end

#add_aro(aro, parents = "*") ⇒ Object 



39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/wizdog/acl/acl.rb', line 39

def add_aro(aro, parents = "*")
  aro_id = aro.respond_to?(:aro_id) ? aro.aro_id.to_s : aro.to_s
  @aros[aro_id] = @aros[aro_id] || {:instance => Aro.new(aro_id), :parents =>{}, :children =>{}}

  parents = [parents] unless parents.is_a?(Array)
  parents.each do |parent|
    parent_id = parent.respond_to?(:aro_id) ? parent.aro_id.to_s : parent.to_s
    @aros[parent_id] = @aros[parent_id] || {:instance => Aro.new(parent_id),:parents =>{}, :children =>{}}
    @aros[aro_id][:parents][parent_id] = @aros[aro_id][:parents][parent_id] || @aros[parent_id][:instance]
    @aros[parent_id][:children][aro_id] = @aros[aro_id][:children][aro_id] || @aros[aro_id][:instance]
  end

end

#allow(aros = "*", acos = "*", operations = "*") ⇒ Object 



79
80
81
82
83
84
85
86
87
88
 
# File 'lib/wizdog/acl/acl.rb', line 79

def allow(aros = "*", acos = "*", operations = "*")
  aros = [aros] unless aros.is_a?(Array)
  acos = [acos] unless acos.is_a?(Array)
  aros.each do |aro|
    acos.each do |aco|
      entry = find_one_entry(aro, aco)
      entry.nil? ? @entries << WizAcl::Entry.new(aro, aco).allow(operations) : entry.allow(operations)
    end
  end
end

#allowed?(aro = "*", aco = "*", operation = "*") ⇒ Boolean

Returns:

  • (Boolean) 


101
102
103
104
105
106
107
108
 
# File 'lib/wizdog/acl/acl.rb', line 101

def allowed?(aro = "*", aco = "*", operation = "*")     
  ###
  permit = dfs_permitted_by_aro(aro, aco, operation)
  return permit unless permit.nil?

  permit = permitted?("*", "*", operation)
  return permit unless permit.nil?
end

#deny(aros = "*", acos = "*", operations = "*") ⇒ Object 



90
91
92
93
94
95
96
97
98
99
 
# File 'lib/wizdog/acl/acl.rb', line 90

def deny(aros = "*", acos = "*", operations = "*")
  aros = [aros] unless aros.is_a?(Array)
  acos = [acos] unless acos.is_a?(Array)
  aros.each do |aro|
    acos.each do |aco|
      entry = find_one_entry(aro, aco)
      entry.nil? ? @entries << WizAcl::Entry.new(aro, aco).deny(operations) : entry.deny(operations)
    end
  end
end

#find_entries_by_aco(aco) ⇒ Object 



131
132
133
134
 
# File 'lib/wizdog/acl/acl.rb', line 131

def find_entries_by_aco(aco)
  aco_id = aco.respond_to?(:aco_id) ? aco.aco_id.to_s : aco.to_s
  @entries.select { |e| e.aco_id == aco_id  }
end

#find_entries_by_aro(aro) ⇒ Object 



126
127
128
129
 
# File 'lib/wizdog/acl/acl.rb', line 126

def find_entries_by_aro(aro)
  aro_id = aro.respond_to?(:aro_id) ? aro.aro_id.to_s : aro.to_s
  @entries.select { |e| e.aro_id == aro_id  }
end

#get_aco(id) ⇒ Object 



67
68
69
 
# File 'lib/wizdog/acl/acl.rb', line 67

def get_aco(id)
  @acos[id][:instance]
end

#get_children_of_aco(id) ⇒ Object 



75
76
77
 
# File 'lib/wizdog/acl/acl.rb', line 75

def get_children_of_aco(id)
  @acos[id] ? @acos[id][:children].values : []
end

#get_parents_of_aco(id) ⇒ Object 



71
72
73
 
# File 'lib/wizdog/acl/acl.rb', line 71

def get_parents_of_aco(id)
  @acos[id][:parents].values
end

#remove_allow(aro = "*", aco = "*", operations = "*") ⇒ Object 



110
111
112
113
114
115
116
 
# File 'lib/wizdog/acl/acl.rb', line 110

def remove_allow(aro = "*", aco = "*", operations = "*")
  entry = find_one_entry(aro,aco)
  if entry && entry.privileges[operations.to_s] == :allow
    entry.privileges.delete(operations.to_s)
    @entries.delete(entry) if entry.privileges.empty?
  end
end

#remove_deny(aro = "*", aco = "*", operations = "*") ⇒ Object 



118
119
120
121
122
123
124
 
# File 'lib/wizdog/acl/acl.rb', line 118

def remove_deny(aro = "*", aco = "*", operations = "*")
  entry = find_one_entry(aro,aco)
  if entry && entry.privileges[operations.to_s] == :deny
    entry.privileges.delete(operations.to_s)
    @entries.delete(entry) if entry.privileges.empty?
  end
end