cantango 0.8.0

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

@@ -0,0 +1,34 @@
+module CanTango
+  module PermissionEngine
+    module Parser
+      class Category < Rule
+       # remove the '@' prefix to get the category name
+       # look up the category and get models referenced by said category
+        attr_reader :categories
+
+        def initialize method, action, target
+          super
+          load_categories
+        end
+
+        def parse
+          cat_name = target.gsub(/^\^/, '').to_sym
+          targets = category_models_for(cat_name).map{|model| parse_class(model)}
+          targets.inject([]) do |statements, target|
+            statements << "#{method}(:#{action}, #{target})"
+          end
+        end
+
+        def category_models_for name
+          categories.registered[name.to_s]
+        end
+
+        def load_categories
+          @categories = CanTango::PermissionEngine::Loader::Categories.new.categories
+        end
+      end
+    end
+  end
+end
+
+

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

@@ -0,0 +1,20 @@
+module CanTango
+  module PermissionEngine
+    module Parser
+      class Default < Rule
+        def parse
+          return default_all if target == 'all'
+          parse_class target
+          "#{method}(:#{action}, #{target})"
+        end
+
+        def default_all
+          "#{method}(:#{action}, :all)"
+        end
+         
+      end
+    end
+  end
+end
+
+

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

@@ -0,0 +1,32 @@
+module CanTango
+  module PermissionEngine
+    module Parser
+      class Ownership < Rule
+        attr_reader :model_class, :owner
+
+        def parse
+          match = target[/(\w+)#(\w+)/]
+
+          @target = match[$1]
+          @owner = match[$2]
+          @model_class = try_class
+          build_ownership_dsl
+        end
+
+        protected
+
+        def build_ownership_dsl
+          raise "#{model_class} has no ##{owner}!" if !model_class.new.respond_to?(owner.to_sym)
+          ownership_dsl_lines
+        end
+
+        def ownership_dsl_lines
+          "#{owner.singularize}_of(#{target}).#{method} :#{action}"
+        end
+      end
+    end
+  end
+end
+
+
+

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

@@ -0,0 +1,33 @@
+module CanTango
+  module PermissionEngine
+    module Parser
+      class Permissions
+
+        def initialize
+        end
+
+        def parse(key, obj, &blk)
+          permission = CanTango::PermissionEngine::Permission.new key
+          case obj
+          when Hash
+            parse_permission(obj, permission, &blk)
+          else
+            raise "Each key must have a YAML hash that defines its permission configuration"
+          end
+          yield permission if blk
+        end
+
+        protected
+
+        # set :can and :cannot on permission with the permission rule
+        def parse_permission(obj, permission, &blk)
+          # Forget keys because I don't know what to do with them
+          obj.each do |key, value|
+            raise ArgumentError, "A CanTango permissions .yml file can only have the keys can: and cannot:" if ![:can, :cannot].include?(key.to_sym)
+            permission.static_rules.send :"#{key}=", value
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+module CanTango
+  module PermissionEngine
+    module Parser
+      class Regex < Rule
+        attr_reader :regex
+
+        def parse
+          target.gsub!(/\/(.*)\//, '\1')
+          @regex = /#{target}/
+          build_statement
+        end
+
+        private
+
+        def targets
+          config_models.by_reg_exp(regex)
+        end
+
+        def build_statement
+          targets.map do |target|
+            "#{method} :#{action}, #{target.name}"
+          end.join("\n")
+        end
+      
+        def config_models
+          CanTango.config.models
+        end
+
+      end
+    end
+  end
+end
+
+
+

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

@@ -0,0 +1,23 @@
+module CanTango
+  module PermissionEngine
+    module Parser
+      class Relationship < Rule
+        def parse
+          match = target[/(\w+)#(\w+)=(.+)/]
+          @target = match[$1]
+          lstat = match[$2]
+          rstat = match[$3]
+
+          model_class = try_class
+          raise "#{model_class} has no ##{lstat}!" if !model_class.new.respond_to?(lstat.to_sym)
+          conditions = ":#{lstat} => #{rstat}"
+
+          target_and_conditions = [ target, conditions ].compact.join(', ')
+          "#{method}(:#{action}, #{target_and_conditions})"
+        end
+      end
+    end
+  end
+end
+
+

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

@@ -0,0 +1,31 @@
+module CanTango
+  module PermissionEngine
+    module Parser
+      class Rule
+
+        attr_reader :method, :action, :model, :target
+
+        def initialize method, action, target
+          @target = target
+          @method = method
+          @action = action
+        end
+
+        def parse
+        end
+
+        def parse_class target = nil
+          @target = target if target
+          try_class.to_s
+        end
+
+        def try_class
+          target.constantize
+        rescue
+          raise "[permission] target #{target} does not have a class so it was skipped"
+        end
+      end
+    end
+  end
+end
+

data/lib/cantango/permission_engine/permission.rb

@@ -0,0 +1,40 @@
+module CanTango
+  module PermissionEngine
+    class Permission
+      # rules is a Hashie, a Hash where keys can also be accessed as method calls
+      attr_accessor :name, :static_rules, :compiled_rules
+
+      def initialize name
+        @name = name
+        @static_rules = Hashie::Mash.new
+        @compiled_rules = Hashie::Mash.new
+      end
+
+      def key
+        name.to_s
+      end
+
+      def to_hash
+        {key => static_rules.to_hash}
+      end
+
+      def to_compiled_hash
+        {key => compiled_rules}
+      end
+
+      def compiled_rules
+        compile_rules!
+        @compiled_rules
+      end
+
+      def compile_rules!
+        compiler.compile! self 
+        @compiled_rules = compiler.to_hashie
+      end
+
+      def compiler
+        @compiler ||= CanTango::PermissionEngine::Compiler.new
+      end
+    end
+  end
+end

data/lib/cantango/permission_engine/selector.rb

@@ -0,0 +1,16 @@
+module CanTango
+  module PermissionEngine
+    module Selector 
+      autoload_modules :Base, :Licenses, :Roles, :RoleGroups, :Users
+
+      def self.create type, collector
+        selector_class(type).new collector
+      end
+
+      def self.selector_class type
+        "CanTango::PermissionEngine::Selector::#{type.to_s.camelize}".constantize
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,19 @@
+module CanTango
+  module PermissionEngine
+    module Selector 
+      class Base
+        attr_reader :subject
+
+        def initialize subject
+          @subject = subject
+        end
+
+        def select permissions
+          permissions.select{|permission| valid? permission }
+        end
+      end
+    end
+  end
+end
+
+

data/lib/cantango/permission_engine/selector/licenses.rb

@@ -0,0 +1,19 @@
+module CanTango
+  module PermissionEngine
+    module Selector
+      class Licenses < Base
+        attr_reader :roles, :role_groups
+
+        def initialize subject
+          @roles  = subject.roles_list
+          @role_groups = subject.role_groups_list
+        end
+
+        def valid? permission
+          (roles | role_groups).include? permission.to_sym
+        end
+      end
+    end
+  end
+end
+

data/lib/cantango/permission_engine/selector/role_groups.rb

@@ -0,0 +1,24 @@
+module CanTango
+  module PermissionEngine
+    module Selector
+      class RoleGroups < Base
+        attr_reader :role_groups
+
+        def initialize collector
+          @role_groups = collector.role_groups_list
+        end
+
+        # TODO: Add roles filter
+        def valid? permission
+          valid_role_groups.include? permission.to_sym
+        end
+
+        def valid_role_groups
+          role_groups - CanTango.config.role_groups.excluded
+        end
+      end
+    end
+  end
+end
+
+

data/lib/cantango/permission_engine/selector/roles.rb

@@ -0,0 +1,25 @@
+module CanTango
+  module PermissionEngine
+    module Selector
+      class Roles < Base
+        attr_reader :roles
+
+        def initialize subject
+          @roles = subject.roles_list
+        end
+
+        # TODO: Add roles filter
+        def valid? permission
+          valid_roles.include?(permission.to_sym)
+        end
+
+        def valid_roles
+          roles - CanTango.config.roles.excluded
+        end
+      end
+    end
+  end
+end
+
+
+

data/lib/cantango/permission_engine/selector/users.rb

@@ -0,0 +1,22 @@
+module CanTango
+  module PermissionEngine
+    module Selector
+      class Users < Base
+        attr_reader :user, :user_key
+
+        def initialize subject
+          @user = subject.user
+          @user_key = user.send(subject.user_key_field)
+        end
+
+        def valid? permission
+          permission == user_key
+        end
+      end
+    end
+  end
+end
+
+
+
+

data/lib/cantango/permission_engine/statement.rb

@@ -0,0 +1,14 @@
+module CanTango::PermissionEngine
+  class Statement
+    attr_reader :method, :action, :conditions
+
+    def initialize method, action, conditions = {}
+      @method, @action, @conditions = [method, action, conditions]
+    end
+
+    def to_code
+      line = conditions.empty? ? "#{method}(:#{action})" : "#{method}(:#{action}, #{conditions})"
+    end
+  end
+end
+

data/lib/cantango/permission_engine/statements.rb

@@ -0,0 +1,35 @@
+module CanTango::PermissionEngine
+  class Statements
+    attr_reader :method, :action
+
+    def initialize method, action, targets
+      @method = method
+      @action = action
+      @targets = targets
+    end
+
+    def to_code
+      parse_statements.join("\n")
+    end
+
+    protected
+
+    def parse_statements
+      targets.inject([]) do |statements, target|
+        statements << parser(target).parse
+      end.flatten
+    end
+
+    def targets
+      @targets ||= []
+    end
+
+    #def statement target_and_conditions
+    #  CanTango::PermissionEngine::Statement.new method, action, target_and_conditions 
+    #end
+
+    def parser target
+      CanTango::PermissionEngine::Parser.create_for method, action, target
+    end
+  end
+end