auth-assistant 0.4.0

data/lib/auth_assistant/role_strategies/all.rb

@@ -0,0 +1,7 @@
+require 'auth_assistant/role_strategies/shared'
+require 'auth_assistant/role_strategies/admin_field'
+require 'auth_assistant/role_strategies/role_field'
+require 'auth_assistant/role_strategies/roles_field'
+require 'auth_assistant/role_strategies/roles_mask'
+require 'auth_assistant/role_strategies/role_assignment'
+require 'auth_assistant/role_strategies/multi_role_assignment'

data/lib/auth_assistant/role_strategies/multi_role_assignment.rb

@@ -0,0 +1,34 @@
+module AuthAssistant          
+  module RoleStrategy
+    module MultiRoleAssignment
+
+      def role?(role)
+        return true if roles && roles.include?(role.to_s)
+        false
+      end      
+
+      module ClassMethods
+        def set_scope
+          scope :with_role, lambda { |role| 
+            joins(:roles, :role_assignments).
+            where("role_assigments.user_id == id AND role_assigments.role_id == role.id AND roles.id == ?", role)            
+          }
+        end
+
+        def set_relationships
+          has_many :role_assignments
+          has_many :roles, :through => :role_assignments
+        end
+      end
+      
+      def self.included(base)  
+        base.extend(ClassMethods)
+      end          
+      
+    end
+  end
+end
+
+
+
+

data/lib/auth_assistant/role_strategies/role_assignment.rb

@@ -0,0 +1,41 @@
+module AuthAssistant          
+  module RoleStrategy
+    module RoleAssignment
+
+      def roles=(*roles)
+        new_role = roles.first.to_s
+        self.role = new_role if CanCan.available_roles.include? new_role
+      end
+
+      def roles
+        [role]
+      end
+
+      def role?(_role)
+        roles.include? _role
+      end  
+
+      module ClassMethods
+        def set_scope
+          scope :with_role, lambda { |role| 
+            joins(:roles).
+            where("user.roles_id = roles.id AND roles.id == ?", role)
+          }
+        end
+
+        def set_relationships
+          has_many :roles
+        end
+      end
+      
+      def self.included(base)  
+        base.extend(ClassMethods)
+      end          
+      
+    end
+  end
+end
+
+
+
+

data/lib/auth_assistant/role_strategies/role_field.rb

@@ -0,0 +1,32 @@
+module AuthAssistant          
+  module RoleStrategy
+    module RoleField
+      
+      def roles=(*roles)
+        new_role = roles.first.to_s
+        self.role = new_role if CanCan.available_roles.include? new_role
+      end
+
+      def roles
+        [role]
+      end
+
+      def role?(_role)
+        roles.include? _role
+      end  
+
+      module ClassMethods
+        def set_scope
+          scope :with_role, lambda { |role| 
+            where("role?(#{role})")
+          }
+        end
+      end
+      
+      def self.included(base)  
+        base.extend(ClassMethods)
+      end
+
+    end
+  end
+end

data/lib/auth_assistant/role_strategies/roles_field.rb

@@ -0,0 +1,31 @@
+module AuthAssistant           
+  module RoleStrategy
+    module RolesField
+      
+      def roles=(*roles)        
+        self.roles = roles.split(',').reject{|e| (e =~ /^\w+$/) == nil}
+      end
+
+      def roles
+        roles.split(',')
+      end
+      
+      def role?(role)
+        roles.include? role.to_s
+      end      
+
+      module ClassMethods
+        def set_scope
+          scope :with_role, lambda { |role|  
+            where("role?(#{role})")
+          }
+        end
+      end
+      
+      def self.included(base)  
+        base.extend(ClassMethods)
+      end
+      
+    end
+  end
+end

data/lib/auth_assistant/role_strategies/roles_mask.rb

@@ -0,0 +1,35 @@
+module AuthAssistant           
+  module RoleStrategy
+    module RolesMask
+
+      def roles=(*roles)        
+        self.roles_mask = (roles & available_roles).map { |r| calc_index(r) }.sum
+      end
+
+      def roles
+        ROLES.reject { |r| ((roles_mask || 0) & calc_index(r)).zero? }
+      end
+      
+      def role?(role)
+        roles.include? role.to_s
+      end      
+
+      module ClassMethods
+        def set_scope
+          scope :with_role, lambda { |role| 
+            where("roles_mask & #{calc_index(role.to_s)} > 0") 
+          }
+        end
+      end
+      
+      def self.included(base)  
+        base.extend(ClassMethods)
+      end
+      
+      protected 
+        def calc_index(r)
+          2**available_roles.index(r)
+        end
+    end
+  end
+end

data/lib/auth_assistant/role_strategies/shared.rb

@@ -0,0 +1,25 @@
+module AuthAssistant    
+  module RoleStrategy
+    module Shared
+      attr_accessor :ability
+      
+      def admin?
+        role? 'admin'
+      end
+
+      def has(ability)
+        @ability ||= ability
+      end
+
+      def owns(clazz)
+        return if !ability
+        base ||= RolePermit::Base.new(ability)
+        base.owns(self, clazz)
+      end
+      
+      def available_roles
+        AuthAssistant::Model.available_roles
+      end
+    end
+  end
+end

data/lib/auth_assistant/translate/authlabels.rb

@@ -0,0 +1,23 @@
+module AuthAssistant
+  module Helpers
+    module AuthLabel          
+      def auth_labels
+        @auth_labels ||= translate_labels
+      end
+
+      def translate_labels
+        ns_actions = 'auth_assistant.actions'
+        labels = {}
+        %w{new edit delete show sign_in sign_out sign_up edit_registration}.each do |action|     
+          labels[action.to_sym] = t "#{ns_actions}.#{action}"
+        end 
+        labels[:confirm] = t 'auth_assistant.confirm'
+        labels           
+      end 
+      
+      def self.included(base)
+        base.helper_method :auth_labels
+      end         
+    end
+  end
+end

data/lib/auth_assistant/view/all.rb

@@ -0,0 +1,4 @@
+require 'auth_assistant/view/auth_menu_item'
+require 'auth_assistant/view/rest_link'
+require 'auth_assistant/view/registration_link'
+require 'auth_assistant/view/session_link'

data/lib/auth_assistant/view/auth_menu_item.rb

@@ -0,0 +1,27 @@
+module AuthAssistant
+  module ViewHelpers
+    module AuthMenuItem
+      def sign_out_menu_item
+        "<li>#{sign_out_link}</li>".html_safe if current_user
+      end
+
+      def sign_in_menu_item
+        "<li>#{sign_in_link}</li>".html_safe if !current_user
+      end
+
+      def sign_up_menu_item
+        "<li>#{sign_up_link}</li>".html_safe if !current_user
+      end
+
+      def edit_registration_menu_item
+        "<li>#{edit_registration_link}</li>".html_safe if current_user
+      end
+
+      alias_method :logout_menu_item, :sign_out_menu_item
+      alias_method :login_menu_item, :sign_in_menu_item  
+      alias_method :register_menu_item, :sign_up_menu_item    
+      alias_method :edit_user_menu_item, :edit_registration_menu_item   
+
+    end  
+  end
+end

data/lib/auth_assistant/view/registration_link.rb

@@ -0,0 +1,30 @@
+module AuthAssistant
+  module ViewHelpers
+    module RegistrationLink
+
+      def sign_up_link(options = {})
+        label = options[:label] || auth_labels[:sign_up]
+        path = registration_path options[:role]
+        link_to(label, path)
+      end
+
+      def edit_registration_link(options = {})
+        label = options[:label] || auth_labels[:edit_registration]
+        path = edit_registration_path options[:role]
+        link_to(label, path)
+      end
+
+      alias_method :register_link, :sign_up_link    
+      alias_method :edit_profile_link, :edit_registration_link
+
+      protected
+        def registration_path(role) 
+          role == 'admin' ? new_admin_registration_path : new_user_registration_path           
+        end
+
+        def edit_registration_path(role) 
+          role == 'admin' ? edit_admin_registration_path : edit_user_registration_path   
+        end
+    end      
+  end
+end

data/lib/auth_assistant/view/rest_link.rb

@@ -0,0 +1,70 @@
+module AuthAssistant
+  module ViewHelpers
+    module RestLink      
+      def index_link(object, label = nil)
+        label ||= auth_labels[:index]                   
+        puts object.inspect        
+        obj = index_obj(object)
+        puts "index obj: #{obj.inspect}"   
+        path = send :"#{obj}_path"    
+        link = link_to(label, path) if can?(:read, object)
+      end      
+      
+      def index_obj(obj)
+        o = case obj
+        when Array 
+          obj.first.class
+        when Class
+          obj
+        else
+          obj.class
+        end 
+        o.name.pluralize.downcase
+      end
+      
+            
+      def create_link(object, label = nil)
+        label ||= auth_labels[:new] 
+        path = send :"new_#{object.class.to_s.downcase}_path"    
+        link = link_to(label, path) if can?(:create, object)
+      end
+
+      def edit_link(object, label = nil)
+       label ||= auth_labels[:edit]
+       link_to(label, [:edit, object]) if can?(:edit, object)
+      end
+
+      def delete_link(object, options = nil)    
+        options ||= {:label => auth_labels[:delete], :confirm => auth_labels[:confirm]}        
+        case options
+        when String
+          label = options
+        when Hash
+          label = options[:label]
+          confirm_msg = options[:confirm]
+        when Array
+          label = options[0]
+          confirm_msg = options.size > 1 ? options[1] : auth_labels[:confirm]
+        end
+       link_to(label, object, :method => :delete, :confirm => confirm_msg) if can?(:destroy, object)
+      end
+
+      def show_link(object, label = nil) 
+        label ||= auth_labels[:show] 
+        if can?(:read, object)
+          puts "can read: #{object}"
+          link_to(label, object)  
+        else
+          puts "no link"
+        end
+      end
+      
+      alias_method :list_link, :index_link
+      alias_method :new_link, :create_link
+      alias_method :destroy_link, :delete_link
+      alias_method :update_link, :edit_link
+      alias_method :read_link, :show_link                  
+      
+    end    
+  end
+end

data/lib/auth_assistant/view/session_link.rb

@@ -0,0 +1,31 @@
+module AuthAssistant
+  module ViewHelpers
+    module SessionLink                                                        
+      def sign_out_link(options = {})
+        label = options[:label] || auth_labels[:sign_out]
+        path = destroy_session_path options[:role]
+        link_to(label, path)
+      end
+
+      def sign_in_link(label, options = {})  
+        label = options[:label] || auth_labels[:sign_in]
+        path = create_session_path options[:role]
+        link_to(label, path)
+      end
+
+      alias_method :log_out_link, :sign_out_link
+      alias_method :log_in_link, :sign_in_link  
+
+      protected
+        def destroy_session_path(role)                                      
+          return send :"destroy_#{role}_session_path" if role && role != 'user'           
+          destroy_user_session_path
+        end
+
+        def create_session_path(role) 
+          return send :"new_#{role}_session_path" if role && role != 'user' 
+          new_user_session_path # default  
+        end            
+    end      
+  end
+end

data/lib/generators/auth_assist/clear/clear_generator.rb

@@ -0,0 +1,30 @@
+require 'generators/migration_helper'
+require 'generators/reverse_migrations'
+require 'generators/role_migrations'
+require 'rake'
+
+module AuthAssist
+  module Generators
+    class ClearGenerator < Rails::Generators::NamedBase       
+
+      desc "Clears the rails project from any artifacts generated by auth_assist" 
+
+      class_option :migration, :type => :boolean, :aliases => "-m", :default => true,
+                                     :desc => "To generate a migration to clear the user role."
+
+      def self.source_root
+        @source_root ||= File.expand_path("../../templates", __FILE__)
+      end
+            
+      def generate_clear_migration 
+        return nil if !options[:migration]        
+        clazz = AuthAssist::RoleMigrations.clazz(name)
+        obj = clazz.new(self)
+        obj.generate_reverse_migration
+        obj.reverse_configure if obj.respond_to? :reverse_configure
+      end
+      
+      include ::AuthAssist::MigrationHelper      
+    end
+  end
+end