acl_plugin 0.0.1

data/LICENSE

@@ -0,0 +1,3 @@
+== AclPlugin
+
+Put appropriate LICENSE for your project here.

data/README

@@ -0,0 +1,3 @@
+== AclPlugin
+
+You should document your project here.

data/Rakefile

@@ -0,0 +1,46 @@
+# 
+# To change this template, choose Tools | Templates
+# and open the template in the editor.
+ 
+
+require 'rubygems'
+require 'rake'
+require 'rake/clean'
+require 'rake/gempackagetask'
+require 'rake/rdoctask'
+require 'rake/testtask'
+
+spec = Gem::Specification.new do |s|
+  s.name = 'acl_plugin'
+  s.version = '0.0.1'
+  s.has_rdoc = true
+  s.extra_rdoc_files = ['README', 'LICENSE']
+  s.summary = 'Your summary here'
+  s.description = s.summary
+  s.author = 'Stefan Riedel'
+  s.email = 'sr@riedel-st.de'
+  s.homepage = 'http://www.riedel-st.de'
+  # s.executables = ['your_executable_here']
+  s.files = %w(LICENSE README Rakefile) + Dir.glob("{bin,lib,spec}/**/*")
+  s.require_path = "lib"
+  s.bindir = "bin"
+end
+
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+Rake::RDocTask.new do |rdoc|
+  files =['README', 'LICENSE', 'lib/**/*.rb']
+  rdoc.rdoc_files.add(files)
+  rdoc.main = "README" # page to start on
+  rdoc.title = "AclPlugin Docs"
+  rdoc.rdoc_dir = 'doc/rdoc' # rdoc output folder
+  rdoc.options << '--line-numbers'
+end
+
+Rake::TestTask.new do |t|
+  t.test_files = FileList['test/**/*.rb']
+end

data/lib/acl.rb

@@ -0,0 +1,167 @@
+module Acl
+  module Resource
+    class Registry
+      attr :resources
+      def initialize
+        @resources = {}
+      end
+      def get_parent(resource)
+        unless self.has?(resource)
+          raise ArgumentError, "#{resource} existiert leider nicht"
+        end
+        @resources[@resources[resource][:parent]][:instance]
+      end
+      def add(resource, parent=nil)
+        if self.has?(resource)
+          raise ArgumentError, "#{resource} existiert leider schon"
+        end
+        unless parent.nil?
+          @resources[parent.to_sym][:children].merge!(resource.to_sym => resource)
+          parent = self.get(parent)
+        end
+        @resources.merge!({resource.to_sym => {
+              :instance => resource,
+              :parent => parent,
+              :children => {}
+            }})
+      end
+      def get(resource)
+        unless self.has?(resource)
+          raise ArgumentError, "#{resource} existiert leider nicht"
+        end
+        @resources[resource.to_sym][:instance]
+      end
+      def has?(resource)
+        @resources.has_key? resource.to_sym
+      end
+      def inherits?(resource, inherit, only_parent=false)
+        unless @resources[resource][:parent].nil?
+          parent = self.get_parent(resource)
+          if parent == inherit
+            return true
+          elsif only_parent
+            return false
+          end
+          while !@resources[parent][:parent].nil?
+              parent = self.get_parent(parent)
+              if parent == inherit
+                return true
+              end
+          end
+        end
+        return false
+      end
+      def remove(resource)
+        unless @resources[resource.to_sym][:parent].nil?
+          @resources[@resources[resource.to_sym][:parent].to_sym][:children].delete(resource.to_sym)
+        end
+        if @resources[resource.to_sym][:children].respond_to?('each_key')
+          @resources[resource.to_sym][:children].each_key do |children_id|
+            self.remove(children_id)
+          end
+        end
+        @resources.delete(resource.to_sym)
+      end
+      def remove_all()
+        @resources = {}
+      end
+      def move(old_parent, new_parent)
+        
+      end
+    end
+  end
+  module Role
+    class Registry      
+      attr :roles
+      #initializer
+      def initialize
+        @roles = {}
+      end
+      #will add a role to the hash
+      #role is an object of Acl::RoleObject
+      #parents will allow an array or a symbol
+      def add(role, parents=nil)
+        if self.has?(role)
+          raise(ArgumentError, "Die rolle existiert leider schon!")
+        end
+        role_parents = {}
+        if parents != nil
+          unless parents.respond_to?(:each) 
+            parent_id = parents.to_sym
+            parents = [parent_id]
+          end
+          parents.each do |parent|
+            current_parent_id = parent.to_sym
+            current_parent_object = self.get current_parent_id
+            role_parents.merge!({current_parent_id => current_parent_object})
+            @roles[current_parent_id][:children].merge!({role.to_sym => role})
+          end
+        end
+        @roles.merge!({role.to_sym => {
+              :instance => role,
+              :parents => role_parents,
+              :children => {}
+            }})
+      end
+      #return the role
+      def get(role)
+        unless self.has?(role)
+          raise(ArgumentError, "#{role.to_sym} existiert leider nicht!")
+        end
+        @roles[role.to_sym][:instance]
+      end
+      #return true if role is in @roles hash
+      def has?(role)
+        @roles.has_key? role.to_sym
+      end
+      def get_parents(role)
+        @roles[role.to_sym][:parents]
+      end
+      #return true if role is in inherits? and if
+      #only_parents are true we will show only in parents hash
+      #of the role
+      def inherits?(role, inherit, only_parents=false)
+        begin
+          role_object = self.get(role)
+          #hier müssen wir ordentliches ausnahme handling einbaun
+        rescue
+          return false
+        end
+        role_id = role_object.to_sym
+        inherit_id = self.get(inherit).to_sym
+        inherits = (@roles[role_id][:parents][inherit_id].nil? == true) ? false : true
+        if  inherits || only_parents
+          return inherits
+        end
+        @roles[role_id][:parents].each_key do |parent_id|
+          if self.inherits?(parent_id, inherit_id)
+            return true
+          end
+        end
+        return false
+      end
+      #removes the role and will return true or false
+      def remove(role)
+        role_id = self.get(role).to_sym
+        if @roles[role_id][:children].respond_to?('each_key')
+          @roles[role_id][:children].each_key do |children_id|
+            @roles[children_id][:parents].delete(role_id)
+          end
+        end
+        if @roles[role_id][:parents].respond_to?('each_key')
+          @roles[role_id][:parents].each_key do |parent_id|
+            @roles[parent_id][:children].delete(role_id)
+          end
+        end
+        @roles.delete(role_id) != nil
+      end
+      #will niling the @roles hash
+      def remove_all
+        @roles = {}
+      end
+      def move(old_parent, new_parent)
+        
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification 
+name: acl_plugin
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+platform: ruby
+authors: 
+- Stefan Riedel
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-06-26 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: Your summary here
+email: sr@riedel-st.de
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+- LICENSE
+files: 
+- LICENSE
+- README
+- Rakefile
+- lib/acl.rb
+has_rdoc: true
+homepage: http://www.riedel-st.de
+licenses: []
+
+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.3.4
+signing_key: 
+specification_version: 3
+summary: Your summary here
+test_files: []
+