Module: ObjectBouncer::Doorman::ClassMethods

Defined in:
lib/objectbouncer/class_methods.rb

Instance Method Summary collapse

Instance Method Details

#apply_policies(key = nil) ⇒ Object 



86
87
88
89
90
91
92
93
94
 
# File 'lib/objectbouncer/class_methods.rb', line 86

def apply_policies(key = nil)
  if key && policies.keys.include?(key)
    protect_method!(key, force = true)
  else
    policies.keys.each do |method|
      protect_method!(method)
    end
  end
end

#as(accessee) ⇒ Object 



55
56
57
58
59
60
61
62
63
64
65
66
67
68
 
# File 'lib/objectbouncer/class_methods.rb', line 55

def as(accessee)
  new_klass = self.clone
  new_klass.table_name = self.table_name if respond_to?(:table_name)
  if respond_to?(:connection_handler)
    new_klass.establish_connection self.connection_handler.connection_pools[name].spec.config
  end
  new_klass.instance_eval do
    include ObjectBouncer::Doorman
  end
  new_klass.policies = self.policies || {}
  new_klass.current_user = accessee
  new_klass.apply_policies
  new_klass
end

#blank_policy_template ⇒ Object 



43
44
45
 
# File 'lib/objectbouncer/class_methods.rb', line 43

def blank_policy_template
  { :if => [], :unless => [] }
end

#current_user ⇒ Object 



51
52
53
 
# File 'lib/objectbouncer/class_methods.rb', line 51

def current_user
  @current_user
end

#current_user=(user) ⇒ Object 



47
48
49
 
# File 'lib/objectbouncer/class_methods.rb', line 47

def current_user=(user)
  @current_user = user
end

#deny(method, options = {}) ⇒ Object 



75
76
77
78
79
80
81
82
83
84
 
# File 'lib/objectbouncer/class_methods.rb', line 75

def deny(method, options = {})
  policies[method] ||= blank_policy_template
  if options.has_key?(:if)
    policies[method][:if] << options[:if]
  elsif options.has_key?(:unless)
    policies[method][:unless] << options[:unless]
  else
    policies[method][:if].unshift(Proc.new{ true == true })
  end
end

#door_policy(&block) ⇒ Object 



70
71
72
73
 
# File 'lib/objectbouncer/class_methods.rb', line 70

def door_policy(&block)
  yield
  apply_policies
end

#ignoring_added_methods ⇒ Object 



5
6
7
8
9
10
11
 
# File 'lib/objectbouncer/class_methods.rb', line 5

def ignoring_added_methods
  ignoring_added_methods = @ignoring_added_methods
  @ignoring_added_methods = true
  yield
ensure
  @ignoring_added_methods = ignoring_added_methods
end

#ignoring_added_methods? ⇒ Boolean

Returns:

  • (Boolean) 


13
14
15
 
# File 'lib/objectbouncer/class_methods.rb', line 13

def ignoring_added_methods?
  @ignoring_added_methods
end

#method_added(name) ⇒ Object 



116
117
118
119
120
121
122
123
124
 
# File 'lib/objectbouncer/class_methods.rb', line 116

def method_added(name)
  return if ignoring_added_methods?
  Thread.exclusive do
    ignoring_added_methods do
      overwrite_initialize if name == :initialize
      apply_policies(name) if policies && policies.keys.include?(name)
    end
  end
end

#overwrite_initialize ⇒ Object 



17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
 
# File 'lib/objectbouncer/class_methods.rb', line 17

def overwrite_initialize
  class_eval do
    unless method_defined?(:objectbouncer_initialize)
      define_method(:objectbouncer_initialize) do |*args, &block|
        original_initialize(*args, &block)
        @policies = self.class.policies
        apply_policies
        self
      end
    end

    if instance_method(:initialize) != instance_method(:objectbouncer_initialize)
      alias_method :original_initialize, :initialize
      alias_method :initialize, :objectbouncer_initialize
    end
  end
end

#policies ⇒ Object 



39
40
41
 
# File 'lib/objectbouncer/class_methods.rb', line 39

def policies
  @policies ||= {}
end

#policies=(hash) ⇒ Object 



35
36
37
 
# File 'lib/objectbouncer/class_methods.rb', line 35

def policies=(hash)
  @policies = hash
end

#protect_method!(method, force = false) ⇒ Object 



96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
 
# File 'lib/objectbouncer/class_methods.rb', line 96

def protect_method!(method, force = false)
  if method_defined?(method)
    renamed_method = "#{method}_without_objectbouncer".to_sym
    new_method     = "#{method}_with_objectbouncer".to_sym
    unless method_defined?(new_method)
      define_method new_method do |*args, &block|
        if call_denied?(method, *args)
          raise ObjectBouncer::PermissionDenied.new
        else
          send(renamed_method, *args, &block)
        end
      end
    end
    if instance_method(method) != instance_method(new_method)
      alias_method renamed_method, method
      alias_method method, new_method
    end
  end
end