cantango-permits 0.1.1

data/lib/cantango/permit/class_methods.rb

@@ -0,0 +1,49 @@
+module CanTango
+  module Permit
+    module ClassMethods
+      def inherited(subclass)
+        unless [CanTango::Permit::Base, CanTango::Permit::Attribute].include?(subclass.superclass)
+          subclass.extend CanTango::Permit::ClassMethods
+          register(subclass)
+        else
+          register_type subclass
+        end        
+      end
+
+      def modes *names
+        @modes ||= []
+        return @modes if names.empty?
+        @modes = names.to_symbols
+      end
+
+      def type
+        :abstract
+      end
+
+      def hash_key
+        raise NotImplementedError
+      end
+
+      def finder
+        @finder ||= CanTango::Finder::Permit::Base.new permit_name(self), :account => account_name(self)
+      end
+
+      protected
+
+      include CanTango::Permit::Helper::Naming
+
+      def register subclass, options = {}
+        permits.register_permit subclass, options.merge(:account => account_name)
+      end
+
+      def register_type clazz
+        CanTango.config.permits.types.register permit_name(clazz)
+      end
+
+      def permits
+        CanTango.config.permits
+      end
+    end
+  end
+end
+

data/lib/cantango/permit/helper.rb

@@ -0,0 +1,11 @@
+module CanTango
+  module Permit
+    module Helper
+      def self.modules
+        [:State, :Execution, :License, :Naming, :Host]
+      end
+      
+      sweetload *modules
+    end
+  end
+end

data/lib/cantango/permit/helper/execution.rb

@@ -0,0 +1,38 @@
+module CanTango::Permit
+  module Helper
+    module Execution
+      include CanTango::Helpers::Debug
+      include CanTango::Permit::Helper::State
+
+      # executes the permit
+      def execute
+        return if disabled?
+        debug "Execute Permit: #{self}"
+                
+        # check current mode and execute accordingly!?
+        calc_rules
+        mode_rules
+      end
+      alias_method :execute!, :execute
+
+      def mode_rules
+        return unless modes.include? mode
+        calc_rules_method = "#{mode}_rules"
+        send(calc_rules_method) if respond_to?(calc_rules_method)
+      end
+
+      # return the executor used to execute the permit
+      def executor
+        @executor ||= case self.class.name
+        when /System/
+          then CanTango::Executor::Permit::System.new self
+        else
+          CanTango::Executor::Permit::Base.new self
+        end
+      end
+
+      def calc_rules
+      end
+    end
+  end
+end

data/lib/cantango/permit/helper/host.rb

@@ -0,0 +1,13 @@
+module CanTango::Permit
+  module Helper
+    module Host
+      def local_host?
+        CanTango.config.localhosts.registered.include? request.host
+      end
+
+      def public_host?
+        !local_host?
+      end
+    end
+  end
+end

data/lib/cantango/permit/helper/license.rb

@@ -0,0 +1,34 @@
+module CanTango::Permit
+  module Helper
+    module License
+      def licenses *names
+        names.to_strings.each do |name|
+          try_license name
+        end
+      end
+
+      def license name
+        raise ArgumentError, "Argument must be a single label" if !name.kind_of_label?
+        licenses name
+      end
+
+      protected
+
+      def license_const name        
+        license_class(name).constantize
+      rescue NameError
+        raise "License #{license_class(name)} is not defined"
+      end
+      
+      def license_class name 
+        "#{name.camelize}License"
+      end
+
+      def try_license name
+        license_const(name).new(self).calc_rules
+      rescue Exception => e
+        raise "License #{license_const(name)} could not be executed: #{e}"
+      end
+    end
+  end
+end

data/lib/cantango/permit/helper/naming.rb

@@ -0,0 +1,38 @@
+module CanTango::Permit
+  module Helper
+    module Naming
+      def permit_name clazz = nil
+        clazz ||= is_class?(self) ? self : self.class
+        return nil unless clazz.name =~ /Permit/
+        namespaces = clazz.name.split('::')
+        name = (namespaces[-2] == 'Permit') ? namespaces.last : namespaces.last.sub(/Permit$/, '')
+        name.underscore.to_sym
+      end
+
+      def account_name clazz = nil
+        clazz ||= is_class?(self) ? self : self.class
+        return nil if clazz.name == clazz.name.demodulize         
+        top_module = clazz.name.gsub(/::.*/,'')
+        return nil unless /Permits$/ =~ top_module 
+        top_module.gsub!(/Account/, '') 
+        top_module.gsub(/(.*)Permits/, '\1').underscore.to_sym
+      end
+      
+      def permit_type clazz = nil
+        clazz ||= is_class?(self) ? self : self.class
+        permit_name clazz.superclass
+      end
+
+      protected
+
+      def first_name clazz = nil
+        clazz ||= is_class?(self) ? self : self.class
+        clazz.to_s.gsub(/^([A-Za-z]+).*/, '\1').underscore.to_sym # first part of class name
+      end
+      
+      def is_class? clazz
+        !clazz.nil? && clazz.respond_to?(:new)
+      end
+    end
+  end
+end

data/lib/cantango/permit/helper/state.rb

@@ -0,0 +1,21 @@
+module CanTango::Permit
+  module Helper
+    module State
+      def disable!
+        @enabled = false
+      end
+
+      def disabled?
+        !enabled?
+      end
+
+      def enable!
+        @enabled = true
+      end
+
+      def enabled?
+        @enabled == true
+      end
+    end
+  end
+end

data/lib/cantango/permit/special.rb

@@ -0,0 +1,17 @@
+module CanTango
+  module Permit
+    class Special < Base
+      def initialize ability
+        super
+      end
+
+      def self.hash_key
+        nil
+      end
+
+      def valid?
+        true
+      end
+    end
+  end
+end

data/lib/cantango/permit/user.rb

@@ -0,0 +1,36 @@
+module CanTango
+  module Permit
+    class User < Base
+      attr_accessor :key, :match_value
+
+      # creates the permit
+      # @param [Permits::Ability] the ability
+      # @param [Hash] the options
+      def initialize ability
+        super
+      end
+
+      def self.hash_key
+        nil
+      end
+
+      def valid?
+        debug_invalid if !match?
+        true
+      end
+
+      protected
+
+      def match?
+        return false if !subject.respond_to? key
+        subject.send(key) == match_value
+      end
+
+      def debug_invalid
+        debug "Not a valid permit for subject: #{key} != #{match_value}"
+      end
+    end
+  end
+end
+
+

data/lib/cantango/permit/user_type.rb

@@ -0,0 +1,34 @@
+module CanTango
+  module Permit
+    class UserType < Base
+      module ClassMethods
+        def hash_key
+          permit_name(self)
+        end
+      end
+      extend ClassMethods
+
+      # creates the permit
+      # @param [Ability] the ability
+      def initialize ability
+        super
+      end
+
+      def valid?        
+        debug_invalid unless user_type == name
+        user_type == name
+      end
+
+      protected
+
+      def debug_invalid
+        debug "Not a valid permit for subject: (user class) #{user_type} != #{name} (permit user)"
+      end
+
+      def user_type
+        user.class.name.underscore.to_sym
+      end
+    end
+  end
+end
+

data/lib/cantango/permits.rb

@@ -0,0 +1,20 @@
+require 'sugar-high/array'
+require 'sugar-high/blank'
+require 'hashie'
+require 'sweetloader'
+
+SweetLoader.namespaces = {:CanTango => 'cantango'}
+SweetLoader.mode = :require
+
+module CanTango
+  sweetload :License, :Permit, :Executor
+end
+
+require 'cantango/permits_ext'
+
+module CanTango
+  module Permit
+    sweetload :Base, :Attribute
+    sweetload :UserType, :AccountType, :Special, :User
+  end
+end

data/lib/cantango/permits_ext.rb

@@ -0,0 +1,7 @@
+module CanTango
+  sweet_scope :ns => {:CanTango => 'cantango/permits_ext'} do
+    sweetload :Ability, :Registry, :Config, :Builder, :Factory
+    sweetload :Finder, :Engine, :Macros, :Parser, :Loader
+    sweetload :ClassMethods
+  end
+end

data/lib/cantango/permits_ext/ability.rb

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

data/lib/cantango/permits_ext/ability/helper.rb

@@ -0,0 +1,9 @@
+module CanTango
+  module Ability
+    module Helper
+      sweet_scope :ns => {:CanTango => 'cantango/permits_ext'} do    
+        sweetload :Permits
+      end
+    end
+  end
+end

data/lib/cantango/permits_ext/ability/helper/permits.rb

@@ -0,0 +1,8 @@
+module CanTango::Ability::Helper
+  module Permits
+    def permits?
+      CanTango.config.permits.on?
+    end
+  end
+end
+

data/lib/cantango/permits_ext/builder.rb

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

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

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

data/lib/cantango/permits_ext/builder/permit/account_type.rb

@@ -0,0 +1,13 @@
+module CanTango
+  module Builder::Permit
+    class AccountType < Base
+      # builds a list of Permits for each role of the current ability user (or account)
+      # @return [Array<RoleGroupPermit::Base>] the role permits built for this ability
+      def build
+        return [] if !account
+        super
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,94 @@
+module CanTango
+  module Builder::Permit
+    class Base
+      class CreatePermitError < StandardError; end
+
+      include CanTango::Helpers::Debug
+
+      attr_accessor :ability, :options
+
+      # delegate to ability
+      delegate :options, :subject, :user, :account, :to => :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, options = {}
+        @ability, @options = [ability, options]
+      end
+
+      module ClassMethods
+        include CanTango::Permit::Helper::Naming
+      end
+      extend ClassMethods
+
+      def permit_type
+        self.class.permit_name
+      end
+
+      # builds a list of Permits for each role of the current ability user (or account)
+      # @return [Array<Permit::Base>] the role permits built for this ability
+      def build
+        debug debug_msg
+        permits
+      end
+
+      protected
+
+      # Tries to create a new permit
+      # If no permit Class can be found, it should return nil
+      # @param [Symbol] the name
+      # @return the permit Class or nil if not found
+      def create_permits
+        begin
+          names.inject([]) do |res, name|
+            permit = permit(name)
+            res << permit if valid?(permit)
+            res
+          end
+        rescue RuntimeError => e
+          debug "Error instantiating Permit instance for #{name}, cause: #{e}"
+          nil
+        end
+      end
+
+      def valid? permit
+        return false if permit.disabled?
+        permit.valid? 
+      end
+
+      def debug_msg
+        permits ? msg(:building) : msg(:not_building)
+      end
+
+      def permits
+        @permit ||= create_permits
+      end
+
+      def permit name
+        clazz = permit_class(name)
+        permit = clazz.new ability if clazz
+      end
+
+      def names
+        CanTango.config.permits.registered_for(permit_type).registered_names
+      end
+
+      def finder name
+        CanTango::Finder::Permit::Base.new name, options.merge(:type => permit_type)
+      end
+
+      def permit_class name
+        finder(name).find_permit
+      end
+
+      def msg type
+        type == :building ? "Building #{htype} permits" : "Not building any #{htype} permits"
+      end
+
+      def htype
+        permit_type.to_s.humanize
+      end
+    end
+  end
+end