has_role.rb in aegis-2.0.0

- old
+ new
@@ -1,110 +1,89 @@
-module Aegis
-  module HasRole
-  
-    def validates_role_name(options = {})
-      validates_each :role_name do |record, attr, value|
-        options[:message] ||= I18n.translate('activerecord.errors.messages.inclusion')
-        role = ::Permissions.find_role_by_name(value)
-        record.errors.add attr, options[:message] if role.nil?
-      end
-    end
-    
-    alias_method :validates_role, :validates_role_name
-
-    def has_role(options = {})
-    
-      # Legacy parameter names
-      options[:accessor] ||= options.delete(:name_accessor)
-      options[:reader] ||= options.delete(:name_reader)
-      options[:writer] ||= options.delete(:name_writer)
-    
-      if options[:accessor]
-        options[:reader] = "#{options[:accessor]}"
-        options[:writer] = "#{options[:accessor]}="
-        options.delete(:accessor)
-      end
-    
-      self.class_eval do
-      
-        class_attribute :aegis_role_name_reader, :aegis_role_name_writer, :aegis_default_role_name
-
-        unless method_defined?(:after_initialize)
-          def after_initialize
-          end
-        end
-
-        if options[:default]
-          self.aegis_default_role_name = options[:default].to_s
-          after_initialize :set_default_aegis_role_name
-        end
-        
-        self.aegis_role_name_reader = (options[:reader] || "role_name").to_sym
-        self.aegis_role_name_writer = (options[:writer] || "role_name=").to_sym
-
-        def aegis_role_name_reader
-          self.class.class_eval{ aegis_role_name_reader }
-        end
-
-        def aegis_role_name_writer
-          self.class.class_eval{ aegis_role_name_writer }
-        end
-
-        def aegis_role_name
-          send(aegis_role_name_reader)
-        end
-
-        def aegis_role_name=(value)
-          send(aegis_role_name_writer, value)
-        end
-
-        def role
-          ::Permissions.find_role_by_name!(aegis_role_name)
-        end
-        
-        def role=(role_or_name)
-          self.aegis_role_name = if role_or_name.is_a?(Aegis::Role)
-            role_or_name.name
-          else
-            role_or_name.to_s
-          end
-        end
-        
-        private
-        
-        # Delegate may_...? and may_...! methods to the user's role.
-        def method_missing_with_aegis_permissions(symb, *args)
-          method_name = symb.to_s
-          if method_name =~ /^may_(.+?)[\!\?]$/
-            role.send(symb, self, *args)
-          elsif method_name =~ /^(.*?)\?$/ && queried_role = ::Permissions.find_role_by_name($1)
-            role == queried_role
-          else
-            method_missing_without_aegis_permissions(symb, *args)
-          end
-        end
-        
-        alias_method_chain :method_missing, :aegis_permissions
-        
-        def respond_to_with_aegis_permissions?(symb, include_private = false)
-          if symb.to_s =~ /^may_(.+?)[\!\?]$/
-            true
-          else
-            respond_to_without_aegis_permissions?(symb, include_private)
-          end
-        end
-        
-        alias_method_chain :respond_to?, :aegis_permissions
-        
-        def set_default_aegis_role_name
-          if new_record? && self.aegis_role_name.blank?
-            self.aegis_role_name = self.class.aegis_default_role_name
-          end
-        end
-        
-      end
-
-    end
-  
-  end
-
-end
+module Aegis
+  module HasRole
+
+    def has_role(options = {})
+
+      if options[:accessor]
+        options[:reader] = "#{options[:accessor]}"
+        options[:writer] = "#{options[:accessor]}="
+        options.delete(:accessor)
+      end
+
+      get_role_name = (options[:reader] || "role_name").to_sym
+      set_role_name = (options[:writer] || "role_name=").to_sym
+
+      permissions = lambda { Aegis::Permissions.app_permissions(options[:permissions]) }
+
+      may_pattern = /^may_(.+?)([\!\?])$/
+
+      send :define_method, :role do
+        permissions.call.find_role_by_name(send(get_role_name))
+      end
+
+      send :define_method, :role= do |role|
+        send(set_role_name, role.name)
+      end
+
+      metaclass.send :define_method, :validates_role do |*validate_options|
+        validate_options = validate_options[0] || {}
+
+        send :define_method, :validate_role do
+          role = permissions.call.find_role_by_name(send(get_role_name))
+          unless role
+            message = validate_options[:message] || I18n.translate('activerecord.errors.messages.inclusion')
+            errors.add get_role_name, message
+          end
+        end
+
+        validate :validate_role
+      end
+
+      if options[:default]
+
+        unless method_defined?(:after_initialize)
+          send :define_method, :after_initialize do
+          end
+        end
+
+        send :define_method, :set_default_role_name do
+          if new_record? && send(get_role_name).blank?
+            send(set_role_name, options[:default])
+          end
+        end
+
+        after_initialize :set_default_role_name
+
+      end
+
+      unless method_defined?(:method_missing_with_aegis_permissions)
+
+        # Delegate may_...? and may_...! methods to the permissions class.
+        send :define_method, :method_missing_with_aegis_permissions do |symb, *args|
+          method_name = symb.to_s
+          if method_name =~ may_pattern
+            action_path = $1
+            severity = $2
+            permissions.call.send("may#{severity}", self, action_path, *args)
+          else
+            method_missing_without_aegis_permissions(symb, *args)
+          end
+        end
+
+        alias_method_chain :method_missing, :aegis_permissions
+
+        send :define_method, :respond_to_with_aegis_permissions? do |symb, *args|
+          if symb.to_s =~ may_pattern
+            true
+          else
+            include_private = args.first.nil? ? false : args.first
+            respond_to_without_aegis_permissions?(symb, include_private)
+          end
+        end
+
+        alias_method_chain :respond_to?, :aegis_permissions
+
+      end
+    end
+
+  end
+end