cantango 0.8.0

data/lib/cantango/rules.rb

@@ -0,0 +1,23 @@
+module CanTango
+  module Rules
+    autoload_modules :Adaptor, :UserRelation, :Dsl, :Scope, :RuleClass
+
+    include Dsl
+    include CanTango::Rules::RuleClass
+    # Examples:
+    #   can :read, Project
+    #   can [:read, :create], [Project, Post]
+    #   can :read, Project, :active => true, :user_id => user.id
+    def can(action, subject, conditions = nil, &block)
+      rules << rule_class.new(true, action, subject, conditions, block)
+    end
+
+    # Examples:
+    #   cannot :read, Project
+    #   cannot [:read, :create], [Project, Post]
+    #   cannot :read, Project, :active => true, :user_id => user.id    
+    def cannot(action, subject, conditions = nil, &block)
+      rules << rule_class.new(false, action, subject, conditions, block)
+    end 
+  end
+end

data/lib/cantango/rules/adaptor.rb

@@ -0,0 +1,32 @@
+module CanTango
+  module Rules
+    module Adaptor
+      autoload_modules :Generic
+      autoload_modules :ActiveRecord, :Mongoid
+
+      # include adaptor depending on which ORM the object inherits from or includes
+      def use_adaptor! base, object
+        orm_map.each_pair do |orm, const|
+          begin
+            adaptor_class = const.constantize
+            base.class.send(:include, adaptor(orm)) if object.kind_of?(adaptor_class)
+          rescue 
+            next
+          end
+        end
+      end
+
+      def adaptor orm
+        "CanTango::Rules::Adaptor::#{orm.to_s.camelize}".constantize
+      end
+
+      def orm_map
+        {
+          :active_record => "ActiveRecord::Base",
+          :mongoid => "Mongoid::Document"
+        }
+      end
+    end
+  end
+end
+

data/lib/cantango/rules/adaptor/active_record.rb

@@ -0,0 +1,13 @@
+module CanTango
+  module Rules
+    module Adaptor
+      module ActiveRecord
+        include CanTango::Rules::Adaptor::Generic
+
+        # Some AR specific rules ...
+        #
+      end
+    end
+  end
+end
+

data/lib/cantango/rules/adaptor/generic.rb

@@ -0,0 +1,16 @@
+module CanTango
+  module Rules
+    module Adaptor
+      module Generic
+
+        def attribute_condition attribute, user_scope
+          Proc.new { |model| model.send(attribute) == user_scope }
+        end
+
+        def include_condition attribute, user_scope
+          Proc.new { |model| model.send(attribute).include? user_scope }
+        end
+      end
+    end
+  end
+end

data/lib/cantango/rules/adaptor/mongoid.rb

@@ -0,0 +1,13 @@
+module CanTango
+  module Rules
+    module Adaptor
+      module Mongoid
+        #include CanTango::Rules::Adaptor::Generic
+        # using #in on Hash (Mongoid query)
+        def list_include
+          { scope_key.in => user_scope.send(attribute) }
+        end
+      end
+    end
+  end
+end

data/lib/cantango/rules/dsl.rb

@@ -0,0 +1,24 @@
+module CanTango
+  module Rules
+    module Dsl
+      def self.included(base)
+        ::CanTango.config.user.relations.each do |relationship|
+          base.class_eval %{
+            def #{relationship}_of *models, &block
+              options = models.extract_options!
+              scope = options[:scope] || :user_account
+              relation = UserRelation.new :#{relationship}, self, scope, *models, &block
+              yield relation if block
+              relation
+            end
+          }
+        end
+      end
+
+      # creates a scope that enforces either using the user or user_account for determining relationship matches on the models
+      def scope name, &block
+        yield CanTango::Rules::Scope.new name, self, &block
+      end
+    end
+  end
+end

data/lib/cantango/rules/rule_class.rb

@@ -0,0 +1,11 @@
+module CanTango
+  module Rules
+    module RuleClass
+      # CanCan 1.5 compatibility
+      def rule_class
+        return CanCan::Rule if defined? CanCan::Rule
+        CanCan::CanDefinition
+      end
+    end
+  end
+end

data/lib/cantango/rules/scope.rb

@@ -0,0 +1,24 @@
+module CanTango
+  module Rules
+    class Scope
+      attr_reader :name, :permit
+
+      def initialize name, permit, &block
+        @name = name.to_sym
+        @permit = permit
+      end
+
+      ::CanTango.config.user.relations.each do |relationship|
+        base.class_eval %{
+          def #{relationship}_of *models, &block
+            options = models.extract_options!
+            scope = options[:scope] || name
+            relation = UserRelation.new :#{relationship}, permit, scope, models, &block
+            yield relation if block
+            relation
+          end
+        }
+      end
+    end
+  end
+end

data/lib/cantango/rules/user_relation.rb

@@ -0,0 +1,68 @@
+require 'active_support/inflector'
+
+module CanTango
+  module Rules
+    class UserRelation
+      attr_reader :attribute, :permit, :scope, :models
+
+      include CanTango::Rules::Adaptor
+      include CanTango::Rules::RuleClass
+
+      def initialize attribute, permit, scope, *models, &block
+        @attribute = attribute
+        @scope = scope
+        @permit = permit
+        @models = models
+
+        check_models
+        use_adaptor! self, user_scope
+      end
+
+      def can(action)
+        models.each do |model|
+          rules << rule_class.new(true, action, model, nil, condition_block(model))
+        end
+      end
+
+      def cannot(action)
+        models.each do |model|
+          rules << rule_class.new(false, action, model, nil, condition_block(model))
+        end
+      end
+
+      protected
+
+      def condition_block model
+        return attribute_condition(attribute, user_scope) if model.new.respond_to?(attribute)
+        return include_condition(plural_attribute, user_scope) if model.new.respond_to?(plural_attribute)
+      end
+
+      def user_scope
+        @user_scope ||= (scope == :account) ? permit.user_account : permit.user
+      end
+
+      def scope_key
+        @scope_key ||= (scope == :account) ? :user_account : :user
+      end
+
+      def ability
+        permit.ability
+      end
+
+      def rules
+        ability.rules
+      end
+
+      def plural_attribute
+        :"#{attribute.to_s.pluralize}"
+      end
+
+      def check_models
+        models.each do |model|
+          raise "#{model} has no :#{attribute} or :#{plural_attribute} defined" if !model.new.respond_to?(attribute) && !model.new.respond_to?(plural_attribute)
+        end
+      end
+
+    end
+  end
+end

data/lib/cantango/users.rb

@@ -0,0 +1,5 @@
+module CanTango
+  module Users
+    autoload_modules :Masquerade, :User, :UserAccount
+  end
+end

data/lib/cantango/users/macros.rb

@@ -0,0 +1,9 @@
+class Module
+  def tango_user
+    self.send :include, CanTango::Users::User
+  end
+
+  def tango_user_account
+    self.send :include, CanTango::Users::UserAccount
+  end
+end

data/lib/cantango/users/masquerade.rb

@@ -0,0 +1,22 @@
+module CanTango
+  module Users
+    module Masquerade
+
+      attr_reader :masquerading
+
+      def masquerade_as user
+        @masquerading = true
+        user = user.kind_of?(String) ? ::User.find(user) : user
+        @active_user = user
+      end
+
+      def stop_masquerade
+        @active_user, @masquerading = nil, nil
+      end
+
+      def masquerading?
+        !@masquerading.nil?
+      end
+    end
+  end
+end

data/lib/cantango/users/masquerade/session_active_user.rb

@@ -0,0 +1,18 @@
+module CanTango
+  module Users
+    module Masquerade
+      module SessionActiveUser
+
+        def active_user
+          session[:active_user]
+        end
+
+        def active_user= user
+          session[:active_user] = user
+        end
+      end
+    end
+  end
+end
+ 
+

data/lib/cantango/users/user.rb

@@ -0,0 +1,30 @@
+module CanTango
+  module Users
+    module User
+
+      include Masquerade
+
+      attr_accessor :active_account
+
+      def active_user
+        @active_user || self
+      end
+
+      def can? *args
+        CanTango::Ability.new(active_account).can?(*args)
+      end
+
+      def cannot? *args
+        CanTango::Ability.new(active_account).cannot?(*args)
+      end
+
+      def active_account
+        @active_account || self
+      end
+
+      def self.included(base)
+        CanTango.config.users.register base.name.underscore
+      end
+    end
+  end
+end

data/lib/cantango/users/user_account.rb

@@ -0,0 +1,23 @@
+module CanTango
+  module Users
+    module UserAccount
+      include CanTango::Users::Masquerade
+
+      def active_user
+        @active_user || user
+      end
+
+      def can? *args
+        CanTango::Ability.new(self).can?(*args)
+      end
+
+      def cannot? *args
+        CanTango::Ability.new(self).cannot?(*args)
+      end
+
+      def self.included(base)
+        CanTango.config.user_accounts.register base.name.underscore.gsub(/_account$/, '')
+      end
+    end
+  end
+end

data/lib/generators/cantango/base.rb

@@ -0,0 +1,52 @@
+require 'rails/generators/base'
+require 'sugar-high/array'
+require 'active_support/inflector'
+require 'rails_artifactor'
+
+module CanTango
+  module Generators
+    class Base < ::Rails::Generators::Base
+      def self.inherited(subclass)
+        subclass.extend ClassMethods
+      end
+
+      module ClassMethods
+        def can_actions
+          [:create, :update, :manage, :read, :access]
+        end
+      end
+      extend ClassMethods
+
+      can_actions.each do |action|
+        class_eval %{
+          class_option :#{action},      :type => :array,     :default => [],  :desc => "Models allowed to #{action}"
+        }
+      end
+
+      protected
+
+      can_actions.each do |action|
+        class_eval %{
+          def #{action}
+            options[:#{action}]
+          end
+        }
+      end
+
+      def rules_logic
+        self.class.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
+
+

data/lib/generators/cantango/license/license_generator.rb

@@ -0,0 +1,34 @@
+require 'rails/generators/base'
+require 'sugar-high/array'
+require 'active_support/inflector'
+require 'rails_artifactor'
+
+require 'generators/cantango/base'
+require 'generators/cantango/license_base'
+
+module CanTango
+  module Generators
+    class LicenseGenerator < CanTango::Generators::Base
+      desc "Creates a License for a Permit in 'app/licenses' with reusable permissions"
+
+      argument     :name,         :type => :string,    :default => '',  :desc => "Name of license"
+
+      class_option :licenses,     :type => :array,     :default => [],  :desc => "Sub licenses"
+
+      source_root File.dirname(__FILE__) + '/templates'
+
+      def main_flow
+        return if name.empty?
+        create_license
+      end
+
+      protected
+
+      def create_license
+        template "license.erb", "app/licenses/#{name}_license.rb"
+      end
+
+      include CanTango::Generators::LicenseBase
+   end
+  end
+end