nakajima-roleful 0.0.1

data/lib/core_ext/array.rb

@@ -0,0 +1,5 @@
+class Array
+  def extract_options!
+    last.is_a?(Hash) ? pop : { }
+  end
+end

data/lib/core_ext/object.rb

@@ -0,0 +1,15 @@
+class Object
+  def try(sym, *args, &block)
+    respond_to?(sym) ? send(sym, *args, &block) : nil
+  end
+  
+  def blank?
+    to_s == nil.to_s
+  end
+
+  unless respond_to?(:instance_exec)
+    def instance_exec(*arguments, &block)
+      block.bind(self)[*arguments]
+    end
+  end
+end

data/lib/core_ext/proc.rb

@@ -0,0 +1,13 @@
+# from activesupport
+class Proc 
+  def bind(object)
+    block, time = self, Time.now
+    (class << object; self end).class_eval do
+      method_name = "__bind_#{time.to_i}_#{time.usec}"
+      define_method(method_name, &block)
+      method = instance_method(method_name)
+      remove_method(method_name)
+      method
+    end.bind(object)
+  end
+end

data/lib/roleful.rb

@@ -0,0 +1,17 @@
+$LOAD_PATH << File.dirname(__FILE__) + '/roleful'
+$LOAD_PATH << File.dirname(__FILE__) + '/core_ext'
+
+require 'rubygems'
+require 'metaid'
+require 'set'
+
+require 'array'
+require 'proc'
+require 'object'
+
+require 'role'
+require 'inclusion'
+
+module Roleful
+  VERSION = '0.0.1'
+end

data/lib/roleful/inclusion.rb

@@ -0,0 +1,75 @@
+module Roleful  
+  def self.included(base)
+    base.class_eval do
+      extend(ClassMethods)
+      include(InstanceMethods)
+      const_set("ROLES", { })
+      const_set("PERMISSIONS", Set.new)
+      define_role(:null)
+    end
+  end
+  
+  module InstanceMethods
+    def with_role(*tmp_roles)
+      old = meta_def(:role) {tmp_roles }
+      result = yield
+      meta_eval { remove_method(:role) }
+      result
+    end
+    
+    alias_method :with_roles, :with_role
+
+    private
+    
+    def role_proxy
+      begin
+        name = (role || :null).is_a?(Array) ?
+          map_roles :
+          self.class::ROLES[role.to_sym]
+      rescue => e
+        warn "#{role.inspect}: #{e}"
+        self.class::ROLES[:null]
+      end
+    end
+    
+    def map_roles
+      role.map { |name| self.class::ROLES[name.to_s.to_sym] }.compact
+    end
+  end
+  
+  module ClassMethods
+    def role(*args, &block)
+      options = args.extract_options!
+      roles = [:all].eql?(args) ? all_roles : args
+      roles.each { |name| define_role(name.to_sym, options, &block) }
+    end
+    
+    # Adapted from ActiveSupport, modified a bit to ease binding contexts
+    def delegate_permission(*methods)
+      options = methods.pop    
+      raise ArgumentError, "Delegation needs a target." unless options.is_a?(Hash) && to = options[:to]
+
+      methods.each do |method|
+        module_eval(<<-EOS, "(__DELEGATION__)", 1)
+          def #{method}(*args, &block)
+            target = Array(send(#{to.inspect}))
+            target.any? do |to|
+              to.__send__(#{method.inspect}, self, *args, &block)
+            end
+          end
+        EOS
+      end
+    end
+    
+    private
+    
+    def all_roles
+      self::ROLES.keys.reject { |name| name.eql?(:null) }
+    end
+    
+    def define_role(name, options={}, &block)
+      self::ROLES[name] ||= Role.new(self, name, options)
+      self::ROLES[name].instance_eval(&block) if block_given?
+    end
+  end
+end

data/lib/roleful/role.rb

@@ -0,0 +1,72 @@
+module Roleful
+  class Role
+    attr_reader :name, :permissions, :handlers, :options
+    
+    def initialize(klass, name, options={})
+      @klass, @name, @options = klass, name, options
+      @permissions = Set.new
+      @handlers = { }
+      define_predicates
+    end
+
+    def can(permission, &block)
+      permission_name = "can_#{permission}?"
+      
+      handlers[permission] = block || proc { true }
+      meta_def(permission_name) { |target, *args| handle(target, permission, *args) }
+      
+      meta_delegate(permission_name)
+      add_permission(permission)
+    end
+    
+    def can?(target, permission, *args)
+      superuser? ?
+        @klass::PERMISSIONS.include?(permission) : 
+        handle(target, permission, *args)
+    end
+    
+    def method_missing(sym, *args)
+      method_id = sym.to_s
+      match_permission_or_predicate?(method_id) ? superuser? : super
+    end
+    
+    private
+    
+    def handle(target, permission, *args)
+      return false if handlers[permission].nil?
+      target.instance_exec(*args, &handlers[permission])
+    end
+    
+    def superuser?
+      options[:superuser] || false # returns false, not nil
+    end
+    
+    def permission?(method)
+      method.match(/can_(#{@klass::PERMISSIONS.to_a.join('|')})+\?/)
+    end
+    
+    def predicate?(method)
+      method.match(/(#{@klass::ROLES.keys.join('|')})\?/)
+    end
+    
+    def match_permission_or_predicate?(method_id)
+      permission?(method_id) or predicate?(method_id)
+    end
+    
+    def define_predicates
+      meta_def("#{name}?") { true }
+      meta_delegate("#{name}?")
+      meta_delegate("can?")
+    end
+    
+    def add_permission(permission)
+      permission = permission.to_sym
+      @permissions.add(permission)
+      @klass::PERMISSIONS.merge(@permissions)
+    end
+    
+    def meta_delegate(name)
+      @klass.delegate_permission name, :to => :role_proxy
+    end
+  end
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: nakajima-roleful
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Pat Nakajima
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2008-10-27 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: metaid
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+description: 
+email: patnakajima@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/core_ext
+- lib/core_ext/array.rb
+- lib/core_ext/object.rb
+- lib/core_ext/proc.rb
+- lib/roleful
+- lib/roleful/inclusion.rb
+- lib/roleful/role.rb
+- lib/roleful.rb
+has_rdoc: false
+homepage: http://github.com/nakajima/roleful
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: Generic roles for you and your objects
+test_files: []
+