cantango-permits 0.1.1

data/Rakefile

@@ -0,0 +1,45 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "cantango-permits"
+  gem.homepage = "http://github.com/kristianmandrup/cantango-permits"
+  gem.license = "MIT"
+  gem.summary = %Q{Permits with engine for cantango}
+  gem.description = %Q{Permit classes and engine for CanTango}
+  gem.email = "kmandrup@gmail.com, s.pankevich@gmail.com"
+  gem.authors = ["Kristian Mandrup", "Stanislaw Pankevich"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test
+
+require 'rdoc/task'
+RDoc::Task.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "cantango-permits #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.1

data/lib/cantango/executor.rb

@@ -0,0 +1,5 @@
+module CanTango
+  module Executor
+    sweetload :Base, :Permit, :PermitType
+  end
+end

data/lib/cantango/executor/base.rb

@@ -0,0 +1,9 @@
+module CanTango
+  module Executor
+    class Base
+      def execute!
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/cantango/executor/permit.rb

@@ -0,0 +1,7 @@
+module CanTango
+  module Executor
+    module Permit
+      autoload_modules :Abstract, :Base, :Special
+    end
+  end
+end

data/lib/cantango/executor/permit/abstract.rb

@@ -0,0 +1,27 @@
+module CanTango
+  module Executor
+    module Permit
+      class Abstract
+        include CanTango::Helpers::Debug
+
+        attr_accessor :permit
+
+        def initialize permit
+          @permit = permit
+        end
+
+        def execute!
+          permit.execute! if permit
+        end
+
+        protected
+        
+        delegate :subject, :rules, :to => :permit
+
+        def valid_for? subject
+          permit.valid_for?(subject) if permit
+        end
+      end
+    end
+  end
+end

data/lib/cantango/executor/permit/base.rb

@@ -0,0 +1,19 @@
+module CanTango
+  module Executor
+    module Permit
+      class Base < Abstract
+        # execute the permit
+        def execute!
+          not_valid_permit and return unless permit.valid?
+          super
+        end
+
+        protected
+
+        def not_valid_permit
+          debug "Permit #{permit} is not valid for #{subject}"
+        end
+      end
+    end
+  end
+end

data/lib/cantango/executor/permit/special.rb

@@ -0,0 +1,9 @@
+module CanTango
+  module Executor
+    module Permit
+      class Special < Base
+      end
+    end
+  end
+end
+

data/lib/cantango/executor/permit_type.rb

@@ -0,0 +1,50 @@
+# This class is responsible for executing a set of similar Permits and collecting their rule results into one rule collection
+# which can be cached under some key and later reused
+#
+module CanTango
+  module Executor
+    class PermitType < Base
+      attr_reader :ability, :permit_type, :permits
+
+      def initialize ability, permit_type, permits
+        @ability      = ability
+        @permit_type  = permit_type
+        @permits      = permits
+      end
+
+      alias_method :cache_key, :permit_type
+
+      def cache
+        @cache ||= CanTango::Ability::Cache.new self, :cache_key => cache_key, :key_method_names => key_method_names
+      end
+
+      def execute!
+        # TODO: somehow type specific caching of result of permits!
+        permits.each do |permit|
+          CanTango.config.permits.was_executed(permit, ability) if CanTango.debug?
+          break if permit.execute == :break
+        end
+      end
+
+      protected
+
+      def valid?
+        true
+      end
+
+      def start_execute
+        debug "Execute #{permit_type} permits"
+      end
+
+      def end_execute
+        debug "Done #{permit_type} permits"
+      end
+
+      def key_method_names
+        permit_class = CanTango.config.permits.available_permits[permit_type]
+        key = permit_class.hash_key if permit_class && permit_class.respond_to?(:hash_key)
+        key ? [key] : []
+      end
+    end
+  end
+end

data/lib/cantango/license.rb

@@ -0,0 +1,19 @@
+module CanTango
+  class License
+    sweetload :Rules
+
+    include Rules
+
+    attr_reader :ability, :licenses
+
+    def initialize ability
+      @ability   = ability
+    end
+
+    def calc_rules
+    end
+
+    def execute
+    end
+  end
+end

data/lib/cantango/license/rules.rb

@@ -0,0 +1,17 @@
+module CanTango
+  class License
+    module Rules
+      def can(action, subject, conditions = nil, &block)
+        ability.can action, subject, conditions, &block
+      end
+
+      def cannot(action, subject, conditions = nil, &block)
+        ability.cannot action, subject, conditions, &block
+      end
+
+      def owns(user_account, clazz, ownership_relation = :user_id, user_id_attribute = :id)
+        ability.owns user_account, clazz, ownership_relation, user_id_attribute
+      end
+    end
+  end
+end

data/lib/cantango/permit.mdown

@@ -0,0 +1,4 @@
+# Permit
+
+The Permit folder contains functionality that work to find and build a Permit to be executed by the
+Permit engine.

data/lib/cantango/permit.rb

@@ -0,0 +1,5 @@
+module CanTango
+  module Permit
+    sweetload :Helper, :ClassMethods
+  end
+end

data/lib/cantango/permit/account_type.rb

@@ -0,0 +1,44 @@
+module CanTango
+  module Permit
+    class AccountType < Base
+      module ClassMethods
+        def type
+          :account
+        end
+
+        def hash_key
+          account_type_name(self)
+        end
+      end
+      extend ClassMethods
+      
+      # creates the permit
+      # @param [Permits::Ability] the ability
+      # @param [Hash] the options
+      def initialize ability
+        super
+      end
+
+      def valid?
+        debug_invalid if !(subject_name == account_name)
+        subject_name == account_name
+      end
+
+      protected
+
+      def debug_invalid
+        puts "Not a valid permit for subject: (account class) #{subject_account} != #{permit_account} (permit account)" if CanTango.debug?
+      end
+
+      def subject_name
+        subject.class.name.sub(/.*(Account)$/, '').underscore.to_sym
+      end
+
+      def account_name
+        permit_name(self.class)
+      end
+    end
+  end
+end
+
+

data/lib/cantango/permit/attribute.rb

@@ -0,0 +1,71 @@
+module CanTango::Permit
+  class Attribute < Base
+    module ClassMethods
+      def attribute name = nil
+        @attribute ||= self.name.demodulize.gsub(/(.*)Permit/, '\1').underscore.to_sym
+        return @attribute unless name
+        @attribute = name
+      end
+
+      alias_method :type, :attribute
+      alias_method :hash_key, :attribute
+
+      def inherited(base_clazz)
+        register_type base_clazz
+        # register base_clazz, :name => attribute_name(base_clazz)
+      end
+    
+      def attribute_name clazz = nil
+        clazz ||= self
+        clazz.name.demodulize.gsub(/(.*)(#{attribute.to_s.camelize}Permit)/, '\1').underscore.to_sym
+      end
+    end
+    extend ClassMethods
+
+    module TestAttribute
+      def plural_attribute
+        @pl ||= attribute.to_s.pluralize
+      end
+
+      def valid?
+        test_single || test_plural
+      end
+  
+      def test_single
+        return false unless subject.respond_to?(attribute)
+        subject.send(attribute) == attribute
+      end
+  
+      def test_plural
+        return false unless subject.respond_to?(plural_attribute)
+        subject.send(plural_attribute).include? attribute
+      end
+    end
+    include TestAttribute
+
+    def permit_name
+      self.class.attribute_name
+    end
+
+    def attribute name = nil
+      self.class.attribute
+    end
+  
+    class Builder < CanTango::Builder::Permit::Base
+      def build
+        return [] unless valid?
+        super
+      end
+    
+      protected
+
+      include CanTango::Permit::Attribute::TestAttribute
+    
+      def self.attribute name = nil
+        raise "No attribute defined" unless name || @attribute
+        return @attribute unless name
+        @attribute = name
+      end
+    end
+  end
+end

data/lib/cantango/permit/base.rb

@@ -0,0 +1,94 @@
+# The permit base class for both Role Permits and Role Group Permits
+# Should contain all common logic
+module CanTango
+  module Permit
+    class Base
+      include CanTango::Helpers::Debug
+      include CanTango::Api::Attributes
+
+      Helper.modules.each do |name|
+        include "CanTango::Permit::Helper::#{name.to_s.camelize}".constantize
+      end
+      extend CanTango::Permit::ClassMethods
+
+      # strategy is used to control the owns strategy (see rules.rb)
+      attr_reader :ability, :strategy, :disabled
+
+      delegate :cached?, :options, :subject, :candidate, :user, :user_account, :rules, :can, :cannot, :to => :ability
+
+      def name
+        self.class.permit_name self.class
+      end
+
+      attr_writer :mode
+
+      # creates the permit
+      def initialize ability
+        @ability  = ability
+      end
+
+      def mode
+        @mode ||= :no_cache
+      end
+
+      def modes
+        self.class.modes
+      end
+
+      def permit_type
+        self.class.permit_type
+      end
+
+      def disable!
+        @disabled = true
+      end
+
+      def disabled?
+        @disabled || CanTango.config.permits.disabled?(permit_type, name)
+      end
+
+      def valid?
+        raise NotImplementedError
+      end
+
+      def category label
+        CanTango.config.models.by_category label
+      end
+
+      def any reg_exp
+        CanTango.config.models.by_reg_exp reg_exp
+      end
+
+      CanTango::Api::Options.options_list.each do |obj|
+        class_eval %{
+          def #{obj}
+            options[:#{obj}]
+          end
+        }
+      end
+
+      def sync_rules!
+        ability.rules << (rules - ability_rules)
+        ability.rules.flatten!
+      end
+
+      protected
+
+      def config_disabled?
+        (CanTango.config.permits.disabled[permit_type] || []).include?(permit_name.to_s)
+      end
+
+      def strategy
+        @strategy ||= options[:strategy] || CanTango::Ability.strategy || :default
+      end
+
+      def any_role_match?
+        role_match?(subject) || role_group_match?(subject)
+      end
+
+      def config
+        CanTango.config
+      end
+    end
+  end
+end