pipa-authmagic 0.0.9 → 0.1

data/lib/authmagic/rails/modules.rb

@@ -2,4 +2,6 @@ module Authmagic::Modules
   autoload :ApplicationFramework, 'authmagic/rails/modules/application_framework'
   autoload :LoginPassword, 'authmagic/rails/modules/login_password'
   autoload :Authorization, 'authmagic/rails/modules/authorization'
+  autoload :LoginRedirector, 'authmagic/rails/modules/login_redirector'
+  autoload :Aliaser, 'authmagic/rails/modules/aliaser'
 end

data/lib/authmagic/rails/modules/application_framework.rb

@@ -4,38 +4,21 @@ module Authmagic
     def initialize(context)
       @context = context
       context.config.session = :session
-      context.config.principal = :user
-
-      class << ActiveRecord::Base
-        def acts_as_principal(options)
-          options.freeze
-          metaclass.send(:define_method, :principal_config) { options }
-        end
-      end
+			context.config.principal = Config.new(:class_name => :user)
     end
 
     def enroll
-      principal = @context.config.principal
+      principal = @context.config.principal.class_name
       principal = principal.to_s.camelize.constantize unless principal.is_a?(Class)
-      @context.config.principal_config = principal.respond_to?(:principal_config) ? principal.principal_config : {}
 
       @context.extend(ContextMethods)
       @context.instance_variable_set(:@principal, principal)
 
-      session = @context.config.session
-      @context.config.new_session_path ||= :"new_#{session}_path"
-      context = @context
+      @context.config.session_controller_name ||= "#{@context.config.session.to_s.camelize.pluralize}Controller"
+			@context.config.new_session_path ||= :"new_#{@context.config.session}_path"
       @context.config.application_controller.class_eval do
         include ApplicationControllerMethods
-        bn = context.principal.name.underscore
-        unless bn == 'principal'
-          cp = "current_#{bn}"
-          cpid = "#{cp}_id"
-          private
-          alias_method cp, :current_principal
-          alias_method cpid, :current_principal_id
-          helper_method cp, cpid
-        end
+				helper_method :current_principal_id, :current_principal, :logged_in?, :if_logged_in
       end
     end
 
@@ -44,75 +27,23 @@ module Authmagic
     end
 
     module ApplicationControllerMethods
-      def self.included(other)
-        other.class_eval do
-          helper_method :current_principal_id, :current_principal, :logged_in?, :if_logged_in
-        end
-        class << other
-          private
-          def require_login(options = {})
-            before_filter(:require_login!, options)
-            rescue_from LoginRequired, :with => :redirect_to_new_session
-          end
-
-          def acts_as_session_controller
-            include SessionControllerMethods
-          end
-        end
-      end
-
       private
       def current_principal_id
         session[:current_principal_id]
       end
 
-      def current_principal
+      def current_principal(options = {})
         id = current_principal_id
-        id && security_context.principal.find(id) rescue ActiveRecord::RecordNotFound nil
-      end
-
-      def require_login!
-        p = current_principal
-        return p if p
-        session[:back_url] = request.url
-        raise LoginRequired
+        id && security_context.principal.find(id, options) rescue ActiveRecord::RecordNotFound nil
       end
 
       def logged_in?
         !!current_principal_id
       end
 
-      def if_logged_in
-        yield current_principal if logged_in?
-      end
-
-      def redirect_to_new_session
-        sp = security_context.config.new_session_path
-        sp = send(sp) if sp.is_a?(Symbol)
-        redirect_to(sp)
-      end
-
-      def redirect_back(default = nil)
-        u, session[:back_url] = session[:back_url], nil
-        redirect_to(u || default)
-      end
-
       def unauthenticate
         session[:current_principal_id] = nil
       end
     end
-
-    module SessionControllerMethods
-      def authenticate(options = {})
-        sess = security_context.config.session
-        cfg = security_context.config.principal_config
-        login = cfg.fetch(:login_field, :login)
-        password = cfg.fetch(:password_field, :password)
-        p = security_context.principal.authenticate(
-          login => options[login] || params[sess][login],
-          password => options[password] || params[sess][password])
-        session[:current_principal_id], session[:current_principal] = p.id, p
-      end
-    end
   end
 end

data/lib/authmagic/rails/modules/authorization.rb

@@ -6,130 +6,45 @@ module Authmagic
 
     def initialize(context)
       @context = context
-
-      context.config.resource_action_map = {
-        :index => :read,
-        :show => :read,
-        :new => :create,
-        :edit => :update,
-      }
     end
 
     def enroll
-      ActiveRecord::Base.metaclass.send(:include, ModelRestrict)
-      @context.principal.send(:include, PrincipalMethods)
-      @context.config.application_controller.metaclass.send(:include, ApplicationControllerRestrict)
-    end
-
-    module PrincipalMethods
-      def may?(action, resource)
-        resource.permitted?(action, self)
-      end
-    end
-
-    module Restrict
-      def restrict(*args, &block)
-        opts = args.extract_options!
-        routine = opts.fetch(:guests, false) ? proc {|p| p && block.call(p) } : block
-        hash = args.empty? ? {nil => routine} : args.inject({}) {|h, x| h[x.to_sym] = routine; h }
-        write_inheritable_hash(:security_permissions, hash)
-        include Permissions
-      end
-    end
-
-    module ApplicationControllerRestrict
-      include Restrict
-      def restrict_with_application_controller(*args, &block)
-        restrict_without_application_controller(*args, &block)
-        include ApplicationControllerMethods
-      end
-      alias_method_chain :restrict, :application_controller
+      @context.config.application_controller.send(:include, ControllerMethods)
     end
 
-    module ModelRestrict
-      include Restrict
-      def restrict_with_model(*args, &block)
-        restrict_without_model(*args, &block)
-        include ModelMethods
+    module ControllerClassMethods
+			private
+			def require_principal(opts = {}, &block)
+				before_filter opts do |controller|
+					controller.instance_eval { deny_action! unless block && block.call(current_principal) }
+				end
       end
-      alias_method_chain :restrict, :model
-    end
 
-    module Permissions
-      def self.included(other)
-        def other.security_permissions
-          read_inheritable_attribute(:security_permissions)
-        end
+			def require_known_principal(opts = {}, &block)
+				require_principal(opts) {|p| p && (!block || block.call(p)) }
       end
 
-      def permitted?(action, principal)
-        permissions = self.class.security_permissions
-        !(routine = permissions[action.to_sym] || permissions[nil]) || routine.call(principal)
-      end
-    end
+			def require_login(opts = {})
+				require_known_principal(opts)
+			end
+		end
 
-    module ApplicationControllerMethods
+		module ControllerMethods
       def self.included(other)
         other.class_eval do
-          alias_method_chain :permitted?, :defaults
-          helper_method :permitted?, :permitted_on?, :if_permitted?, :if_permitted_on?
-          before_filter :check_authorization
-          rescue_from Unauthorized, :with => :handle_unauthorized
+					extend ControllerClassMethods
+          rescue_from Unauthorized, :with => :forbid!
         end
       end
 
       private
-      def check_authorization
-        deny! unless permitted?
+      def deny_action!
+				raise Unauthorized
       end
 
-      def handle_unauthorized
+      def forbid!
         head :forbidden
       end
-
-      def permitted_with_defaults?(action = action_name, principal = current_principal)
-        permitted_without_defaults?(action, principal)
-      end
-
-      def if_permitted(action = action_name, principal = current_principal)
-        yield if permitted?(action, principal)
-      end
-
-      def deny!
-        raise Unauthorized
-      end
-
-      def deny_if!(condition = nil)
-        deny! if condition
-        yield if block_given?
-      end
-
-      def permit_if!(condition = nil, &block)
-        deny_if!(!condition, &block)
-      end
-
-      def guard!(resource, action = action_name, principal = current_principal, &block)
-        resource.guard!(principal, _map_resource_action(action), &block)
-      end
-
-      def permitted_on?(resource, action = action_name, principal = current_principal)
-        resource.may?(principal, _map_resource_action(action))
-      end
-
-      def if_permitted_on(resource, action = action_name, principal = current_principal)
-        yield if permitted_on?(resource, action, principal)
-      end
-
-      def _map_resource_action(action)
-        security_context.config.resource_action_map.fetch(action, action)
-      end
-    end
-
-    module ModelMethods
-      def guard!(action, principal)
-        raise Unauthorized unless permitted?(action, principal)
-        yield if block_given?
-      end
     end
   end
 end

data/lib/authmagic/rails/modules/login_password.rb

@@ -11,11 +11,11 @@ module Authmagic
     def enroll
       principal = @context.principal
 
-      cfg = @context.config.principal_config
+      cfg = @context.config.principal
       login = cfg.fetch(:login_field, :login)
       case_sensitive = case cfg.fetch(:compare, :case_sensitive)
-      when :case_sensitive then true
-      when :case_insensitive then false
+      when :cs, :case_sensitive then true
+      when :ci, :case_insensitive then false
       else raise 'bad :compare value'
       end
       password = cfg.fetch(:password_field, :password)
@@ -91,6 +91,22 @@ module Authmagic
         define_method generate_salt do
           ActiveSupport::SecureRandom.send(secran_salt, salt_length)
         end
+      end
+
+			@context.config.session_controller_name.constantize.send(:include, SessionControllerMethods)
+    end
+
+		module SessionControllerMethods
+			private
+      def authenticate_with_login_password(options = {})
+        sess = security_context.config.session
+        cfg = security_context.config.principal
+        login = cfg.fetch(:login_field, :login)
+        password = cfg.fetch(:password_field, :password)
+        p = security_context.principal.authenticate(
+          login => options[login] || params[sess][login],
+          password => options[password] || params[sess][password])
+        session[:current_principal_id] = p.id
       end
     end
   end

data/rails_generators/authmagic/templates/sessions_controller.rb

@@ -3,7 +3,7 @@ class SessionsController < ApplicationController
   end
 
   def create
-    authenticate
+    authenticate_with_login_password
     flash[:notice] = "Login successful!"
     redirect_back account_url
   rescue SecurityError => e
@@ -12,7 +12,7 @@ class SessionsController < ApplicationController
   end
 
   def destroy
-    destroy_session
+    unauthenticate
     flash[:notice] = "Logout successful!"
     redirect_back new_session_url
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: pipa-authmagic
 version: !ruby/object:Gem::Version 
-  version: 0.0.9
+  version: "0.1"
 platform: ruby
 authors: 
 - Igor Gunko
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-01-20 00:00:00 -08:00
+date: 2009-01-21 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency