rack_warden 0.0.9 → 0.0.10

data/lib/rack_warden/core_patches.rb

@@ -0,0 +1,20 @@
+# Simple conversion to html (intended for yaml output)
+class String
+	def to_html
+		self.gsub(/\n|\r/, '<br>').gsub(/  /, '&nbsp;&nbsp;')
+	end
+end
+
+class Hash
+	# Extract key-value pairs from self, given list of objects.
+	# If last object given is hash, it will be the collector for the extracted pairs.
+	# Extracted pairs are deleted from the original hash (self).
+	# Returns the extracted pairs as a hash or as the supplied collector hash.
+	# Attempts to ignore case.
+	def extract(*args)
+		other_hash = args.last.is_a?(Hash) ? args.pop : {}
+		other_hash.tap do |other|
+			self.delete_if {|k,v| (args.include?(k) || args.include?(k.to_s) || args.include?(k.to_s.downcase) || args.include?(k.to_sym)) || args.include?(k.to_s.downcase.to_sym) ? other[k]=v : nil}
+		end
+	end
+end

data/lib/rack_warden/env.rb

@@ -0,0 +1,27 @@
+module RackWarden
+	module Env
+		
+		def cookies
+  		self['rack.cookies']
+  	end
+  	
+  	def remember_token
+  		cookies[App.settings.remember_token_cookie_name]
+	  end
+
+  	def remember_token=(string)
+  		App.logger.debug "RW env.remember_token= #{string} (#{App.settings.remember_token_cookie_name})"
+  		cookies[App.settings.remember_token_cookie_name]= string
+	  end
+	  
+	  def rack_warden
+  		self['rack_warden_instance']
+	  end
+	  
+	  def rack_warden=(object)
+	  	App.logger.debug "RW env['rack_warden_instance']=  #{object === Class ? object.name : object.class.name}"
+  		self['rack_warden_instance'] = object
+	  end
+	  
+	end
+end

data/lib/rack_warden/frameworks.rb

@@ -1,47 +1,45 @@
 module RackWarden
   module Frameworks
-    module Base
-      
-      # Module methods to be called on Base from RackWarden::App (and instance).
-      class << self
-        # Select the framework of the parent app.
-        def select_framework(env)
-          #puts "RW framework constants: #{Frameworks.constants}"
-          Frameworks.constants.dup.tap{|_constants| _constants.delete(:Base)}.each do |c|
-            r = Frameworks.const_get(c).framework_selector(env) #rescue nil
-            return r if r
-          end
-          nil
-        end
-        
-        # Extend target with target (like saying 'extend self').
-        def extended(target)
-          target.extend target
+
+    # Module methods.
+    class << self
+    	attr_accessor :selected_framework
+    	
+      # Select the framework of the parent app.
+      def select_framework(env)
+        App.logger.debug "RW framework constants: #{constants}"
+        self.constants.dup.tap{|_constants| _constants.delete(:Base)}.each do |c|
+          @selected_framework = self.const_get(c).framework_selector(env)
+          break if @selected_framework
         end
+        @selected_framework ||= Rack
+      	App.logger.info "RW selected framework #{@selected_framework}"
+        @selected_framework
       end
       
+      # Extend target with target (like saying 'extend self' within target).
+      def extended(target)
+        target.extend target
+      end
+    end
+    
 
-      ###  Methods extended into framework module  ###
-
-      attr_accessor :parent_app_instance, :parent_app_class, :parent_app, :rack_warden_app_instance, :rack_warden_app_class
+    ###  Methods extended into framework module  ###
 
-      # Sets framework module with variables from env (the scope of the parent app's initializer),
-      # and runs the framework selector logic.
-      # Returns the framework module or nil.
-      def framework_selector(env)
-      	#puts "RW testing framework #{self}"
-        #puts "BASE.framework_selector #{self} env: #{env.eval 'self'} locals: #{env.eval 'local_variables'}"
-        @initialization_args = env.eval 'initialization_args'
-        @parent_app_instance = env.eval 'parent_app_instance'
-        @parent_app_class = @parent_app_instance.class
-        @parent_app = @parent_app_instance.is_a?(Class) ? @parent_app_instance : @parent_app_class
-        @rack_warden_app_instance = env.eval 'self'
-        @rack_warden_app_class = @rack_warden_app_instance.class
-        selector && self
-      end
+    attr_accessor :parent_app_instance, :parent_app_class, :parent_app
 
-      ###  End methods extended into framework module  ###
-    	
+    # Sets framework module with variables from env (the scope of the parent app's initializer),
+    # and runs the framework selector logic.
+    # Returns the framework module or nil.
+    def framework_selector(app)
+    	App.logger.debug "RW framework_selector #{self}"
+      @parent_app_instance = app #env.eval 'parent_app_instance'
+      @parent_app_class = @parent_app_instance.class
+      @parent_app = @parent_app_instance.is_a?(Class) ? @parent_app_instance : @parent_app_class
+      selector && self
     end
+
+    ###  End methods extended into framework module  ###
+  	
   end
 end

data/lib/rack_warden/frameworks/rack.rb

@@ -0,0 +1,36 @@
+module RackWarden
+  module Frameworks
+    module Rack
+      
+      extend Frameworks
+            
+      def selector
+        App.logger.debug "RW Rack.selector parent_app.ancestors #{parent_app.ancestors}"
+        parent_app.ancestors.find{|x| x.to_s=='Rack::URLMap'}
+      end
+      
+      def views_path
+        [File.join(Dir.pwd, "views/rack_warden"), File.join(Dir.pwd,"views")]
+      end
+      
+      module ClassMethods
+				# def require_login(*args)
+				# 	App.logger.debug "RW class.require_login self #{self}, args #{args}"
+				# 	before(*args) do
+				# 		require_login
+				# 	end
+				# end
+      end
+      
+      def setup_framework
+        App.logger.debug "RW setup_framework for rack app #{parent_app}"
+  			parent_app.include(RackWarden::UniversalHelpers)
+        App.logger.info "RW registering class methods with #{parent_app}"
+  			parent_app.extend ClassMethods
+  			App.set :rack_authentication, '.*'
+  			#parent_app.require_login(RackWarden::App.require_login) if RackWarden::App.require_login != false
+    	end
+    	
+    end # Rack
+  end # Frameworks
+end # RackWarden

data/lib/rack_warden/frameworks/rails.rb

@@ -2,28 +2,48 @@ module RackWarden
   module Frameworks
     module Rails
       
-      extend Base
+      extend Frameworks
 
       def selector
-        #puts "RW Rails.selector parent_app.ancestors #{parent_app.ancestors}"
-        parent_app.ancestors.find{|x| x.to_s[/Rails|ActionDispatch/]} or defined?(Rails)
+        App.logger.debug "RW Rails.selector parent_app.ancestors #{parent_app.ancestors}"
+        parent_app.ancestors.find{|x| x.to_s[/Rails|ActionDispatch/]} or defined?(::Rails)
       end
       
       def views_path
         [File.join(Dir.pwd, "app/views/rack_warden"), File.join(Dir.pwd, "app/views")]
       end
       
+
+      module ClassMethods
+				def require_login(*args)
+					App.logger.debug "RW running #{self}.require_login(#{args.inspect})"
+					#before_filter(*[:require_login, args].flatten.compact)
+					before_filter(*args) do |controller|
+						controller.send :require_login
+					end
+				end
+      end
+
+
       def setup_framework
-        #puts "RW setup_framework for rails"
-    		ActionController::Base.send(:include, RackWarden::UniversalHelpers)
+        App.logger.debug "RW setup_framework for rails"
+    		m = Module.new.include(RackWarden::UniversalHelpers)
+    		m.send :protected, *(m.instance_methods)
+    		ActionController::Base.send(:include, m)
+
+    		ActionController::Base.helper_method UniversalHelpers.instance_methods
     			      
 	      # Define class method 'require_login' on framework controller.
-				ActionController::Base.define_singleton_method :require_login do |conditions_hash={}|
-					before_filter(:require_login, conditions_hash)
-				end
+	      # Note that rails before-filters are also class methods, thus the need to differentiate method names (is this correct?).
+	      App.logger.info "RW defining ActionController::Base.require_login"
+				# ActionController::Base.define_singleton_method :require_login do |*args|
+				# 	conditions_hash = args[0] || Hash.new
+				# 	before_filter(:require_login, conditions_hash)
+				# end
+				ActionController::Base.extend ClassMethods
 				
     		# The way you pass arguments here is fragile. If it's not correct, it will bomb with "undefined method 'before'...".
-    		(ActionController::Base.require_login (rack_warden_app_class.require_login || {})) if rack_warden_app_class.require_login != false
+    		(ActionController::Base.require_login(RackWarden::App.require_login || {})) if RackWarden::App.require_login != false
       end
             
     end

data/lib/rack_warden/frameworks/sinatra.rb

@@ -2,10 +2,10 @@ module RackWarden
   module Frameworks
     module Sinatra
       
-      extend Base
+      extend Frameworks
             
       def selector
-        #puts "RW Sinatra.selector parent_app.ancestors #{parent_app.ancestors}"
+        App.logger.debug "RW Sinatra.selector parent_app.ancestors #{parent_app.ancestors}"
         parent_app.ancestors.find{|x| x.to_s=='Sinatra::Base'}
       end
       
@@ -13,17 +13,21 @@ module RackWarden
         [File.join(Dir.pwd, "views/rack_warden"), File.join(Dir.pwd,"views")]
       end
       
+      module ClassMethods
+				def require_login(*args)
+					App.logger.debug "RW class.require_login self #{self}, args #{args}"
+					before(*args) do
+						require_login
+					end
+				end
+      end
+      
       def setup_framework
-        #puts "RW setup_framework for sinatra"
+        App.logger.debug "RW setup_framework for sinatra app #{parent_app}"
   			parent_app.helpers(RackWarden::UniversalHelpers)
-  			  			
-        # Define class method 'require_login' on framework controller.
-				parent_app.define_singleton_method :require_login do |accept_conditions=/.*/, reject_conditions=false|
-					before(accept_conditions){require_login unless reject_conditions}
-				end
-				
-				# Add require_login to before filter of sinatra app.
-  			parent_app.require_login(rack_warden_app_class.require_login) if rack_warden_app_class.require_login != false
+        App.logger.info "RW registering class methods with #{parent_app}"
+  			parent_app.register ClassMethods
+  			parent_app.require_login(RackWarden::App.require_login) if RackWarden::App.require_login != false
     	end
     	
     end # Sinatra

data/lib/rack_warden/helpers.rb

@@ -1,89 +1,257 @@
 module RackWarden
 
+
+	module AppClassMethods
+	
+		def self.registered(app)
+			app.initialize_app_class
+		end
+	
+	  # Main RackWarden::App class setup.
+	  def initialize_app_class
+      
+	  	initialize_logging
+	  	logger.warn "RW initializing RackWarden::App in process #{$0}"
+	  	logger.warn "RW running in #{environment} environment"
+	  	initialize_config_files
+	  	initialize_logging
+	  		  	
+	    use Rack::Cookies
+	    Namespace::NamespacedMethods.prefixed :require_login
+	    Sinatra::Namespace::NamespacedMethods.prefixed(:require_login) if Sinatra.const_defined?(:Namespace) && Sinatra::Namespace.const_defined?(:NamespacedMethods)
+	    
+	    register RackWarden::Namespace
+	    register RackWarden::RespondWith
+	    	  	
+  		# Setup flash if not already
+  		# TODO: put code to look for existing session management in rack middlewares (how?). See todo.txt for more.
+			use Rack::Flash, :accessorize=>[:rw_error, :rw_success, :rw_test]
+				  	
+			helpers RackWarden::WardenConfig
+			helpers RackWarden::Routes
+			
+	    helpers RackWardenHelpers
+	    helpers UniversalHelpers
+	    
+	  end
+		
+		def setup_framework(app, *args)
+			opts = args.last.is_a?(Hash) ? args.pop : {}
+			# Get framework module.
+			framework_module = Frameworks.select_framework(app)
+			#logger.info "RW selected framework module #{framework_module}"
+			
+			# Prepend views from framework_module if framework_module exists.
+			# TODO: should this line be elsewhere?
+			settings.overlay_settings(:views=>framework_module.views_path) if framework_module && ![settings.views, opts[:views]].flatten.include?(false)
+			
+			# Overlay settings with opts.
+			settings.overlay_settings opts				
+			
+			# Setup framework if framework_module exists.
+			framework_module.setup_framework if framework_module
+		end
+
+    # Load config from file, if any exist.
+    def initialize_config_files(more_config={})
+	    Hash.new.tap do |hash|
+	      config_files.each {|c| hash.merge!(YAML.load_file(File.join(Dir.pwd, c))) rescue nil}
+	      hash.merge! more_config
+	      overlay_settings hash
+	    end
+    end
+    
+    # Apply new settings on top of existing settings, prepending new views to old views.
+    def overlay_settings(new_settings)
+    	new_views = new_settings.extract(:views).values
+    	logger.debug "RW overlay_settings new_views #{new_views.inspect}"
+	  	set :views, [new_views, views].flatten.compact.uniq
+    	set new_settings
+    end
+    	
+    # Initialize logging.
+    def initialize_logging(reset=reset_logger)
+	    # We take existing log file from settings, enable sync (disables buffering), then put it back in settings.
+    	_log_file = !logging && File.new('/dev/null', 'a') || !reset && settings.log_file || File.new(settings.log_path, 'a+')
+	    _log_file.sync = true
+	    set :log_file, _log_file
+	    set :logger, Logger.new(_log_file, 'daily') unless settings.logger && !reset
+	    logger.level = eval "Logger::#{log_level}"
+	    
+	    # Setup Rack::CommonLogger
+	    if use_common_logger
+	    	mw = @middleware.find {|m| Array(m)[0] == Rack::CommonLogger}
+		    #@middleware.delete_if {|m| Array(m)[0] == Rack::CommonLogger}
+		    mw ? mw[1]=[_log_file] : use(Rack::CommonLogger, _log_file)
+	    end
+	    
+		  #if logger.level < 2
+			  #DataMapper::Logger.new(_log_file)  #$stdout) #App.log_path)
+			  DataMapper.logger.instance_variable_set :@log, _log_file
+			  DataMapper.logger.instance_variable_set :@level, DataMapper::Logger::Levels[log_level.to_s.downcase.to_sym]
+			  # logger.info "RW DataMapper using log_file #{_log_file.inspect}"
+		  #end
+	    
+	    logger.debug "RW initialized logging (level #{logger.level}) #{_log_file.inspect}"
+	  rescue
+	  	puts "There was an error setting up logging: #{$!}"
+	  end
+
+	  # Creates uri-friendly codes/keys/hashes from raw unfriendly strings (like BCrypt hashes). 
+	  def uri_encode(string)
+	  	URI.encode(Base64.encode64(string))
+	  end
+	  
+	  def uri_decode(string)
+	  	Base64.decode64(URI.decode(string))
+	  end
+	  
+	  # Generic template rendering. Does not have automatic access to 'controller' environment.
+	  # Pass 'object' to be the context of rendered template.
+  	# See this for more info on using templates here http://stackoverflow.com/questions/5446283/how-to-use-sinatras-haml-helper-inside-a-model.
+	  def render_template(template_name, locals_hash={}, object=self )
+		  tmpl = settings.views.collect {|v| Tilt.new(File.join(v, template_name)) rescue nil}.compact[0]
+		  if tmpl
+		  	tmpl.render(object, locals_hash)
+		  else
+			  App.logger.info "RW self.render_template found no templates to render" 
+			  nil
+			end
+		end
+
+	end # AppClassMethods
+
+
 	module UniversalHelpers
-	protected
+	#protected ... might need this for rails, but not for sinatra.
 		
 		def require_login
-			#puts "RW instance #{self}.require_login with rack_warden: #{rack_warden}, and warden: #{warden}"
-			warden.authenticate!
+			App.logger.debug "RW running #{self}.require_login with rack_warden: #{rack_warden}, and warden: #{warden}"
+			#App.logger.debug "RW instance #{self}.require_login ancestors #{self.class.ancestors.inspect}"
+			#logged_in? || warden.authenticate!
+			warden.authenticated? || warden.authenticate!
 	  end
 	
 		def warden
 	    request.env['warden']
 		end
+		
+		def warden_options
+	    request.env['warden.options']
+		end
 	
 		def current_user
-	    warden.user
+	    #warden.authenticated? && warden.user
+	    logged_in? && warden.user
 		end
 	
 		def logged_in?
-	    warden.authenticated?
+			App.logger.debug "RW logged_in? #{warden.authenticated?}"
+	    warden.authenticated? || warden.authenticate(:remember_me)
 		end
 		
-		def authorized?(authenticate_on_fail=false)
-			unless current_user.authorized?(request)
+		def authorized?(options=request)
+			App.logger.debug "RW authorized? user '#{current_user}'"
+			current_user && current_user.authorized?(options) || request.script_name[/login|new|create|logout/]
+		end
+
+		def require_authorization(authenticate_on_fail=false, options=request)
+			App.logger.debug "RW require_authorization"
+			logged_in? || warden.authenticate!
+			unless authorized?(options)
 				if authenticate_on_fail
-					flash(:rwarden)[:error] = ("Please login to continiue")
-					redirect "/auth/login"
+					flash[:rw_error] = ("Please login to continiue")
+					redirect url_for("/login")
 				else
-					flash(:rwarden)[:error] = ("You are not authorized to do that")
+					flash[:rw_error] = ("You are not authorized to do that")
 					redirect back
 				end
-			end
+			end		
 		end
 
 		# Returns the current rack_warden app instance stored in env.
 	  def rack_warden
-	  	#puts "rack_warden method self #{request.env['rack_warden']}"
-	  	request.env['rack_warden_instance']
+	  	App.logger.debug "RW helper method 'rack_warden' request.env['rack_warden_instance'] #{request.env['rack_warden_instance']}"
+	  	request.env['rack_warden_instance'] #.tap {|rw| rw.request = request}    #request}
+	  end
+	  
+	  def account_widget
+	  	rack_warden.erb :'rw_account_widget.html', :layout=>false
+	  end
+	  
+	  def flash_widget
+	  	App.logger.debug "RW flash_widget self.flash #{self.flash}"
+	  	App.logger.debug "RW flash_widget rack.flash #{env['x-rack.flash']}"
+	  	App.logger.debug "RW flash_widget.rack_warden.flash #{rack_warden.request.env['x-rack.flash']}"
+	  	rack_warden.erb :'rw_flash_widget.html', :layout=>false
 	  end
 	
 	end # UniversalHelpers
 
+
+
+
 	# Also bring these into your main app helpers.
 	module RackWardenHelpers
+
+		# Access main logger from app instance.
+		def logger
+			settings.logger
+		end
+	
 	  # WBR - override. This passes block to be rendered to first template that matches.
 		def find_template(views, name, engine, &block)
-			# puts "THE VIEWS: #{views}"
-			# puts "THE NAME: #{name}"
-			# puts "THE ENGINE: #{engine}"
-			# puts "THE BLOCK: #{block}"
+			logger.debug "RW find_template name: #{name}, engine: #{engine}, block: #{block}, views: #{views}"
 	    Array(views).each { |v| super(v, name, engine, &block) }
 	  end
-	
-	
-	  # TODO: Shouldn't these be in warden block above? But they don't work there for some reason.
-	
+	  
+	  # Because accessing app instance thru env seems to loose flash access.
+	  def flash
+	  	request.env['x-rack.flash']
+	  end
+		
 	  def valid_user_input?
 	    params['user'] && params['user']['email'] && params['user']['password']
 	  end
+
+		def rw_prefix(_route='')
+			settings.rw_prefix.to_s + _route.to_s
+		end
+		
+		def url_for(_url, _full_uri=false)
+			url(rw_prefix(_url), _full_uri)
+		end
+		
+		
 	
 		def verify_recaptcha(skip_redirect=false, ip=request.ip, response=params['g-recaptcha-response'])
 			secret = settings.recaptcha[:secret]
 	 		_recaptcha = ActiveSupport::JSON.decode(open("https://www.google.com/recaptcha/api/siteverify?secret=#{secret}&response=#{response}&remoteip=#{ip}").read)
-	    puts "RECAPTCHA", _recaptcha
+	    logger.warn "RW recaptcha #{_recaptcha.inspect}"
 	    unless _recaptcha['success']
-	    	flash(:rwarden)[:error] = "Please confirm you are human"
+	    	flash.rw_error = "Please confirm you are human"
 	    	redirect back unless skip_redirect
 	    	Halt "You appear to be a robot."
 	    end
 	  end
 	
 	  def default_page
-			nested_erb :'rw_index.html', :'rw_layout_admin.html', settings.layout    #settings.layout
+			nested_erb :'rw_index.html', :'rw_layout_admin.html', settings.layout
 	  end
 		
 	  def nested_erb(*list)
-	  	template = list.shift
-	  	counter =0
-	  	list.inject(template) do |tmplt, lay|
-	  		#puts "RW LAYOUTS lay: #{lay}, rslt: #{tmplt}"
+	  	list.inject do |tmplt, lay|
 	  		erb tmplt, :layout=>lay
 	  	end
 	  end
 	  
 	  def return_to(fallback=settings.default_route)
-	  	redirect session[:return_to] || url(fallback, false)
+	  	redirect session[:return_to] || url_for(fallback)
+	  end
+	  
+	  def redirect_error(message="Error")
+	  	flash.rw_error = message
+			redirect url_for("/error")
 	  end
 	  
 	  def account_bar