cantango 0.8.0

data/lib/cantango/permission_engine/collector.rb

@@ -0,0 +1,43 @@
+module CanTango
+  module PermissionEngine
+    class Collector
+      attr_reader :ability, :permissions, :type
+
+      def initialize ability, permissions, type
+        @ability = ability
+        @permissions = permissions
+        @type = type
+      end
+
+      def build
+        relevant_rules.inject([]){|evaluators, (name, rules)| 
+          evaluators << CanTango::PermissionEngine::Evaluator.new(ability, rules) 
+        }
+      end
+
+      def relevant_rules
+        selector.select permissions
+      end
+
+      def selector
+        CanTango::PermissionEngine::Selector.create type, self
+      end
+
+      def role_groups_list
+        ability.role_groups
+      end
+
+      def roles_list
+        ability.roles
+      end
+
+      def user
+        ability.user
+      end
+
+      def user_key_field
+        ability.user_key_field
+      end
+    end
+  end
+end

data/lib/cantango/permission_engine/compiler.rb

@@ -0,0 +1,67 @@
+module CanTango
+  module PermissionEngine
+    class Compiler
+      attr_reader :permission, :categories
+
+      def initialize
+      end
+
+      def compile! permission
+        @permission = permission
+        self
+      end
+
+      def to_hashie
+        Hashie::Mash.new(eval_statements)
+      end
+
+      def eval_statements
+        {:can => can_eval, :cannot => cannot_eval}
+      end
+
+      def can_eval &block
+        build_statements :can, &block
+      end
+
+      def cannot_eval &block
+        build_statements :cannot, &block
+      end
+
+      protected
+
+      # build the 'can' or 'cannot' statements to evaluate
+      def build_statements method, &block
+        return nil if !permission.static_rules.send(method)
+        yield statements(method) if !statements(method).empty? && block
+        statements(method)
+      end
+
+      def statements method
+        valid_actions.map do |action|
+          statements_string(method, :action => action)
+        end.compact.join("\n")
+      end
+
+      # returns the targets the permission rule can manage
+      # Example: permission.can[:manage]
+      # returns ['Article', 'Comment']
+      def get_targets method, action
+        permission.static_rules.send(method).send(:[], action.to_s)
+      end
+
+      # TODO can and cannot should allow for multiple actions!
+      # TODO: should be refactored to more like can([:read, :write], [Article, Comment])
+      # Example: can(:manage, [Article, Comment])
+      def statements_string method, options = {}
+       action = options[:action]
+       targets = get_targets method, action
+       targets ? CanTango::PermissionEngine::Statements.new(method, action, targets).to_code : nil
+      end
+
+      def valid_actions
+        [:manage, :read, :update, :create, :write]
+      end
+    end
+  end
+end
+ 

data/lib/cantango/permission_engine/evaluator.rb

@@ -0,0 +1,34 @@
+module CanTango
+  module PermissionEngine
+    class Evaluator
+      attr_reader :ability, :rule
+
+      include CanTango::Rules
+
+      def initialize ability, rule
+        @ability = ability
+        @rule = rule
+        safe_rules!
+      end
+
+      def evaluate! user
+        @user = user
+        instance_eval rule.can if rule.can?
+        instance_eval rule.cannot if rule.cannot?
+      end
+
+      def rules
+        ability.send :rules
+      end
+     
+      def user
+        @user
+      end
+
+      def safe_rules!
+        rule.can.gsub!(/(User|UserAccount)/,'::\1') if rule.can?
+        rule.cannot.gsub!(/(User|UserAccount)/,'::\1') if rule.cannot?
+      end
+    end
+  end
+end

data/lib/cantango/permission_engine/factory.rb

@@ -0,0 +1,60 @@
+require 'sugar-high/class_ext'
+
+module CanTango
+  module PermissionEngine
+    class Factory
+      include ClassExt
+
+      attr_accessor :ability
+
+      # creates the factory for the ability
+      # note that the ability contains the roles and role groups of the user (or account)
+      # @param [Permits::Ability] the ability
+      def initialize ability
+        @ability = ability
+      end
+
+      def build!
+        @evaluators ||= permission_types.inject([]) do |res, type|
+          res << collector(type).build
+          res
+        end.flatten.compact
+      end
+
+      def collector(type)
+        rules = store.send(:"#{type}_rules")
+        CanTango::PermissionEngine::Collector.new(ability, rules, type)
+      end
+
+      def options
+        ability.options
+      end
+
+      def store
+        store_class.new :cantango_permissions, store_options
+      end
+
+      def store_class
+        permissions_engine.store.default_class
+      end
+
+      def store_options
+        permissions_engine.store.options.merge(:path => config_path)
+      end
+
+      def permission_types
+        permissions_engine.types
+      end
+
+      def config_path
+        permissions_engine.config_path
+      end
+
+      private
+
+      def permissions_engine
+        CanTango.config.permissions
+      end
+    end
+  end
+end

data/lib/cantango/permission_engine/loader.rb

@@ -0,0 +1,7 @@
+module CanTango
+  module PermissionEngine
+    module Loader
+      autoload_modules :Base, :Categories, :Permissions
+    end
+  end
+end

data/lib/cantango/permission_engine/loader/base.rb

@@ -0,0 +1,39 @@
+module CanTango
+  module PermissionEngine
+    module Loader
+      class Base
+        attr_accessor :file_name
+
+        def self.inherited(subclass)
+          subclass.extend ClassMethods
+        end
+
+        def parser
+          raise NotImplementedError
+        end
+
+        def file_name= file
+          raise "Couldn't find permissions file: #{file}" if file.nil? || !File.file?(file)
+          @file_name = file
+        end
+
+        def yml_content
+          YAML.load_file(file_name)
+        end
+
+        module ClassMethods
+          protected
+
+          def config_file name
+            File.join(config_path, "#{name}.yml") if rails?
+          end
+
+          def config_path
+            CanTango.config.permissions.config_path
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/cantango/permission_engine/loader/categories.rb

@@ -0,0 +1,50 @@
+module CanTango
+  module PermissionEngine
+    module Loader 
+      class Categories < Base
+        attr_reader :file_name, :categories
+
+        def initialize file = nil
+          begin
+            @file_name = file || categories_config_file
+            yml_content.each do |key, value|
+              parser.parse(categories, key, value)
+            end
+
+          rescue RuntimeError => e
+            raise "CanTango::Categories::Loader Error: The categories for the file #{file_name} could not be loaded - cause was #{e}"
+          end
+        end
+
+        def category name
+          categories.category(name).subjects
+        end
+
+        def categories
+          @categories ||= CanTango.config.categories
+        end
+
+        def parser
+          @parser ||= CanTango::PermissionEngine::Parser::Categories.new
+        end
+
+        def load_categories name = nil
+          name ||= categories_config_file
+          CanTango::Categories::Loader.new name
+        end
+
+        def categories_config_file
+          get_config_file 'categories'
+        end
+
+        def get_config_file name
+          File.join(config_path, "#{name}.yml")
+        end
+
+        def config_path
+          CanTango.config.permissions.config_path
+        end
+      end
+    end
+  end
+end

data/lib/cantango/permission_engine/loader/permissions.rb

@@ -0,0 +1,66 @@
+module CanTango
+  module PermissionEngine
+    module Loader
+      class Permissions < Base
+        attr_accessor :permissions
+
+        def initialize file_name
+          self.file_name = file_name
+          load!
+        end
+
+        def load_from_hash hash
+          hash.each do |type, groups|
+            groups.each do |group, rules|
+              permissions[type] ||= {}
+              parser.parse(group, rules) do |permission|
+                permissions[type][permission.name] = permission
+              end
+            end
+          end
+        rescue => e
+          raise "PermissionsLoader Error: The permissions for the file #{file_name} could not be loaded - cause was #{e}"
+        end
+
+        def load!
+          yml_content.each do |type, groups|
+            (permissions[type] = {} # This is for having fx empty users: section 
+             next) if groups.nil?   #
+            groups.each do |group, rules|
+              permissions[type] ||= {}
+              parser.parse(group, rules) do |permission|
+                permissions[type][permission.name] = permission
+              end
+            end
+          end
+        rescue => e
+          raise "PermissionsLoader Error: The permissions for the file #{file_name} could not be loaded - cause was #{e}"
+        end
+
+        def permissions
+          @permissions ||= Hashie::Mash.new
+        end
+
+        def parser
+          @parser ||= CanTango::PermissionEngine::Parser::Permissions.new
+        end
+
+        CanTango.config.permissions.types.each do |type|
+          define_method(:"#{type}_permissions") {
+            permissions.send(:"#{type}")
+          }
+
+          define_method(:"#{type}_compiled_permissions") {
+            compiled_sum = send(:"#{type}_permissions").inject({}) do |compiled_sum, (actor, permission)|
+              compiled_sum.merge(permission.to_compiled_hash)
+            end
+            Hashie::Mash.new(compiled_sum)
+          }
+
+        end
+
+        include ClassMethods
+      end
+    end
+  end
+end

data/lib/cantango/permission_engine/moneta_store.rb

@@ -0,0 +1,30 @@
+require 'moneta'
+require 'active_support/inflector'
+
+module CanTango
+  class Permission
+    class MonetaStore < Store
+      # one cache store is shared for all store instances (w different names)
+      attr_reader :store
+
+      # for a YamlStore, the name is the name of the yml file
+      def initialize name, options = {}
+        super
+        @store = CanTango::Cache::MonetaCache.instance 
+        @store.configure_with options
+      end
+
+      def self.create name, options = {}
+        super
+      end
+
+      def load!
+        store.load! name
+      end
+
+      def store permissions
+        store.save! name, permissions.map {|p| p.to_a }
+      end
+    end
+  end
+end

data/lib/cantango/permission_engine/parser.rb

@@ -0,0 +1,32 @@
+module CanTango
+  module PermissionEngine
+    module Parser
+      autoload_modules :Categories, :Permissions
+      autoload_modules :Category, :Default, :Ownership, :Relationship, :Regex, :Rule
+
+      def self.create_for method, action, target
+        type = parser_type target
+        parser_name = "CanTango::PermissionEngine::Parser::#{type.to_s.camelize}"
+        parser_class = parser_name.constantize
+        parser_class.new method, action, target
+      end
+
+      protected
+
+      def self.parser_type target
+        case target.to_s
+        when /\/(.*)\//
+          :regex
+        when /^\^(\w+)/ # a category is prefixed with a '^<D-^>s'
+          :category
+        when /\w+#\w+=.+/
+          :relationship
+        when /\w+#\w+/
+          :ownership
+        else
+          :default
+        end
+      end
+    end
+  end
+end

data/lib/cantango/permission_engine/parser/categories.rb

@@ -0,0 +1,18 @@
+module CanTango
+  module PermissionEngine
+    module Parser
+      class Categories
+
+        def parse categories, key, obj, &blk
+          case obj
+          when Array
+            categories[key] = obj
+          else
+            raise "Each key must have a YAML hash that defines which models make up the category (related kinds of items)"
+          end
+          yield categories if blk
+        end
+      end
+    end
+  end
+end