cantango-permits 0.1.1

data/lib/cantango/permits_ext/finder.rb

@@ -0,0 +1,7 @@
+module CanTango
+  module Finder
+    sweet_scope :ns => {:CanTango => 'cantango/permits_ext'} do
+      sweetload :Base, :Permit
+    end
+  end
+end

data/lib/cantango/permits_ext/finder/base.rb

@@ -0,0 +1,35 @@
+module CanTango
+  module Finder
+    class Base
+      include CanTango::Helpers::Debug
+
+      attr_reader :type, :name
+
+      def initialize name, options
+        @name = name.to_s.underscore.to_sym 
+        @type = options[:type]
+        raise ArgumentError, "Missing name of permit to find" if !name
+        raise ArgumentError, "Missing type of permit to find" if !type
+      end
+
+      def permit
+        debug permit_msg(found_permit)
+        found_permit
+      end
+
+      protected
+
+      def permit_msg
+        found_permit.nil? ? "no #{type} permits found named #{name}" : "#{type} permit found named: #{name} -> #{found_permit}"
+      end
+
+      def permits
+        registered_permits.registered_for(type)
+      end
+      
+      def registered_permits
+        CanTango.config.permits
+      end          
+    end
+  end
+end

data/lib/cantango/permits_ext/finder/permit.rb

@@ -0,0 +1,7 @@
+module CanTango::Finder
+  module Permit
+    sweet_scope :ns => {:CanTango => 'cantango/permits_ext'} do
+      sweetload :Base, :Account
+    end
+  end
+end

data/lib/cantango/permits_ext/finder/permit/account.rb

@@ -0,0 +1,47 @@
+module CanTango
+  module Finder
+    module Permit
+      class Account < Base
+        attr_reader :user_account
+
+        def initialize name, options = {}
+          super
+          @account = options[:account]
+        end
+
+        def find_permit
+          retrieve_permit
+        end
+
+        def permits
+          account_registry.registered_for(type)
+        end
+
+        def account_registry
+          CanTango.config.permits.accounts.registry_for(account)
+        end
+
+        protected
+
+        def found_permit
+          @found_permit ||= permits.registered[name]
+        end
+
+        def permits_to_try
+          [permit]
+        end
+
+        # this is used to namespace role permits for a specific type of user account
+        # this allows role permits to be defined differently for each user account (and hence sub application) if need be
+        # otherwise it will fall back to the generic role permit (the one which is not wrapped in a user account namespace)
+        def permit_class
+          [permit_ns , permit_class].join('::')
+        end
+
+        def permit_ns
+          "#{account}Permits"
+        end
+      end
+    end
+  end
+end

data/lib/cantango/permits_ext/finder/permit/base.rb

@@ -0,0 +1,53 @@
+module CanTango
+  module Finder
+    module Permit
+      class Base < CanTango::Finder::Base
+        include CanTango::Helpers::Debug
+
+        # This class is used to find the right permit, possible scoped for a specific user account
+        attr_reader :account
+
+        def initialize name, options = {}
+          super
+          @account = options[:account]
+        end
+
+        def find_permit
+          raise find_error if !retrieve_permit
+          retrieve_permit
+        end
+
+        def account_finder name
+          @account_finder ||= CanTango::Finder::Permit::Account.new name, :type => type, :account => account
+        end
+
+        protected
+
+        def permit_msg found
+          found.nil? ? "no permits found for #{name}" : "permits registered for name: #{name} -> #{found}"
+        end
+
+        def found_permit
+          @found_permit ||= permits.registered.send(name)
+        end
+        alias_method :registered?, :found_permit
+
+        def account_permit
+          account_finder(name).find_permit
+        end
+
+        def find_error
+          "The #{type} Permit for #{name} could not be loaded. You need to define a coresponding Permit class"
+        end
+
+        def retrieve_permit
+          @found_permit ||= permits_to_try.first
+        end
+
+        def permits_to_try
+          @permits_to_try ||= [account_permit, permit].compact
+        end
+      end
+    end
+  end
+end

data/lib/cantango/permits_ext/loader.rb

@@ -0,0 +1,7 @@
+module CanTango
+  module Loader
+    sweet_scope :ns => {:CanTango => 'cantango/permits_ext'} do
+      sweetload :Categories, :License
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+module CanTango
+  module Loader
+    class Categories < Yaml
+      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
+      rescue
+        []
+      end
+
+      def categories
+        @categories ||= CanTango.config.categories
+      end
+
+      def parser
+        @parser ||= CanTango::Parser::Categories.new
+      end
+
+      def load_categories name = nil
+        name ||= categories_config_file
+        CanTango::Loader::Categories.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.engine(:permit).config_path
+      end
+    end
+  end
+end

data/lib/cantango/permits_ext/loader/license.rb

@@ -0,0 +1,19 @@
+module CanTango
+  module Loader
+    class License
+      def load_rules name = nil
+        return if !licenses || licenses.permissions.empty?
+        name ||= self.class.to_s.gsub(/License$/, "").underscore
+
+        return if licenses.permissions[name].nil?
+
+        licenses.permissions[name].can_eval do |permission_statement|
+          instance_eval permission_statement
+        end
+        licenses.permissions[name].cannot_eval do |permission_statement|
+          instance_eval permission_statement
+        end
+      end
+    end
+  end
+end

data/lib/cantango/permits_ext/macros.rb

@@ -0,0 +1,7 @@
+module CanTango
+  module Macros
+    sweet_scope :ns => {:CanTango => 'cantango/permits_ext'} do
+      sweetload :Permit
+    end
+  end
+end

data/lib/cantango/permits_ext/macros/permit.rb

@@ -0,0 +1,32 @@
+module CanTango
+  module Permit
+    class MissingTypeError < StandardError; end
+    class MissingNameError < StandardError; end
+  end
+  
+  module Macros
+    module Permit
+      def tango_permit options = {}
+        name = options[:name] || CanTango::Macros::Permit.permit_name(self)
+        account = options[:account] || CanTango::Macros::Permit.account_name(self)
+        super_class = self.superclass
+        class_type = unless super_class == Object
+          super_class.respond_to?(:type) ? super_class.type : nil
+        end
+        type = options[:type] || class_type
+
+        raise CanTango::Permit::MissingNameError, "Name of permit could not be determined, try specifying a :name option" if name.nil?
+        raise CanTango::Permit::MissingTypeError, "Type of permit could not be determined, try specifying a :type option" if type.nil?
+
+        reg_options = {:name => name, :type => type, :account => account}
+        CanTango.config.permits.register self, reg_options
+        reg_options
+      end      
+      extend CanTango::Permit::Helper::Naming
+    end
+  end
+end
+
+class Class
+  include CanTango::Macros::Permit
+end

data/lib/cantango/permits_ext/parser.rb

@@ -0,0 +1,7 @@
+module CanTango
+  module Parser
+    sweet_scope :ns => {:CanTango => 'cantango/permits_ext'} do
+      sweetload :Categories
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+module CanTango
+  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

data/lib/cantango/permits_ext/registry.rb

@@ -0,0 +1,7 @@
+module CanTango
+  module Registry
+    sweet_scope :ns => {:CanTango => 'cantango/permits_ext'} do
+      sweetload :Permit
+    end
+  end
+end

data/lib/cantango/permits_ext/registry/permit.rb

@@ -0,0 +1,45 @@
+module CanTango
+  module Registry
+    module Permit
+      def registry_for type
+        raise ArgumentError, "Not an available permit type, was: #{type} - available: #{available_types}" unless available_type? type
+        inst_var_name = "@#{type}"
+        instance_variable_set(inst_var_name, CanTango::Registry::Hash.new) if !instance_variable_get(inst_var_name)
+        instance_variable_get(inst_var_name)
+      end
+
+      def registered_for type, name = nil
+        name ? registry_for(type)[name.to_s] : registry_for(type)
+      end
+
+      def all
+        (available_types - [:special]).map{|type| registry_for(type) }
+      end
+
+      def show_all
+        (available_types - [:special]).map{|type| "#{type} -> #{show_hash_reg(registry_for(type))}"  }.join("\n")
+      end
+      
+      protected
+
+      def show_hash_reg reg
+        reg.registered.map {|key, value| "#{key} (#{value})" }.join(',')
+      end
+
+      def available_type? type
+        available_types.include? type
+      end
+      
+      def available_types
+        CanTango.config.permits.types.available
+      end
+      
+      class Base
+        include CanTango::Registry::Permit
+      end
+    end
+  end
+end
+
+
+

data/lib/generators/cantango/account_permit/account_permit_generator.rb

@@ -0,0 +1,37 @@
+require 'generators/cantango/base'
+require 'generators/cantango/license_base'
+require 'generators/cantango/permit_generator'
+
+module Cantango
+  module Generators
+    class AccountPermitGenerator < Cantango::Generators::Base
+      desc "Creates a Permit for an account in 'app/permits' with specific permissions and/or licenses"
+
+      argument     :account,        :type => :string,   :desc => "Account class to create permit for"
+
+      class_option :licenses,       :type => :array,    :default => [],     :desc => "Licenses to use in Permit"
+
+      class_option :account,        :type => :string,
+          :desc => "Generate permits for a specific user account"
+
+      class_option :group,          :type => :boolean,  :default => false,  :desc => "Generate permit for a role group"
+
+      source_root File.dirname(__FILE__) + '/templates'
+
+      def main_flow
+        template_permit account
+      end
+
+      protected
+
+      def is_account?
+        true
+      end
+
+      include Cantango::Generators::LicenseBase
+      include Cantango::Generators::PermitGenerator
+    end
+  end
+end
+
+

data/lib/generators/cantango/account_permit/templates/account_permit.erb

@@ -0,0 +1,23 @@
+class <%= account.to_s.camelize %>AccountPermit < CanTango::AccountPermit
+  def initialize ability
+    super
+  end
+
+  protected
+
+  def permit_rules
+    # insert your can, cannot and any other rule statements here
+    <%= permit_logic.strip %>
+    <%= license_logic %>
+  end
+
+  module Cached
+    def permit_rules
+    end
+  end
+
+  module NonCached
+    def permit_rules
+    end
+  end
+end

data/lib/generators/cantango/base.rb

@@ -0,0 +1,71 @@
+require 'generators/cantango/basic'
+
+module Cantango
+  module Generators
+    class Base < ::Rails::Generators::Base
+
+      include Cantango::Generators::Basic
+
+      CAN_ACTIONS = [:create, :update, :manage, :read, :access]
+
+      CAN_ACTIONS.each do |action|
+        class_eval %{
+          class_option :#{action},      :type => :array,     :default => [],  :desc => "Models allowed to #{action}"
+          class_option :not_#{action},  :type => :array,     :default => [],  :desc => "Models not allowed to #{action}"
+        }
+      end
+
+      protected
+
+      [:user, :account].each do |name|
+        define_method :"#{name}?" do
+          false
+        end
+      end
+
+      CAN_ACTIONS.each do |action|
+        class_eval %{
+          def #{action}
+            options[:#{action}]
+          end
+        }
+      end
+
+      CAN_ACTIONS.each do |action|
+        class_eval %{
+          def not_#{action}
+            options[:not_#{action}]
+          end
+        }
+      end
+
+      def rules_logic
+        can_logic
+        cannot_logic
+      end
+
+      def can_logic
+        CAN_ACTIONS.map do |action|
+          send(action).map do |c|
+            "can(:#{action}, #{act_model(c)})"
+          end.join("\n    ")
+        end.join("\n")
+      end
+
+      def cannot_logic
+        CAN_ACTIONS.map do |action|
+          send(action).map do |c|
+            "can(:#{action}, #{act_model(c)})"
+          end.join("\n    ")
+        end.join("\n")
+      end
+
+      def act_model name
+        return ':all' if name == 'all'
+        name.camelize
+      end
+    end
+  end
+end
+
+