rack_warden 0.0.9 → 0.0.10

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    OGI4OGQxNWNhZTkwNWNlODQ3ZTkwNWFmZTZiODFkM2MwNTMzNWZkZg==
+    Yzg2NzVkNGE1Yzc3NWIwYmNhZDkxMGNkMDE3MzZiZGU3MTNkMDQwOQ==
   data.tar.gz: !binary |-
-    YWFiYWY3NmRjNzZmNjJhMzIzM2Y2YjFmY2I5OGVjMmI5OGFmMDQ4Mg==
+    M2UzZTNiM2UxOGFhYjBhN2VmNzI4OGM1N2UyMDk1NDBmNWI5MjI1OQ==
 SHA512:
   metadata.gz: !binary |-
-    NWVlZDdkMzczOTIwMjYzY2I4NjZiZmExNzlmYWQyZmU5OGJjYTg1YWUyZDA3
-    YzcwNDYzOGZiMzBlNDg2NjQ2ZmI1YTBkNjU3MTc0YTFiM2Y3NTgzZTQyNzNk
-    MjUyMGI2NzVlMTkwOWQ0ODdiZWRhYzVkMTI5ZDFjMWNhMzhjZGE=
+    ZTk4MmI2YmU5YTg1OTM3MWFkMjc3YjExOTQwYjY5ZTI5N2U4NWI3YmE2ZWU2
+    YjAwMGE1NDBjODU5NGE4OWVmYjIzM2FhYzUyY2VlYTJhYjEyNTk3YTk1M2E5
+    NmJkNDA0NDI0N2JlZmM2ZjcyZTVmY2RiNzM3Zjg1M2RiZTM5NzU=
   data.tar.gz: !binary |-
-    YzQ3ZTIzMjMyNWQ4YTRmMmQxMTRiNjMwNDliOTkwN2IyZTVjOGY3MjQ3MGIz
-    ODg0ZTBhMTk3ZmE4MzE3YTNiNzhjN2ExMGJmYTZhNGViZDJhYjNlOGNiZTky
-    MjhhMzE4MWFkMzAyZDUyZGMwZmYwYjQ0ZDQ5Mjk2NmE1ZDA4MWI=
+    MmYxYWIzOWQ5YWNhZDE1ZTNlYTAwNTYwMzRlZWVhM2QxMTkzNWVlYTcyNGNm
+    ZDNmNDAyNjFlMzBlMTYzNzMwNWFhY2Y2Zjg1MGIxMjQyY2ExNTQ4MmJjMTY3
+    M2VjZmFiMzU1NDNiNDc5ODc4YTI3OTM1MWUyNzM0OWY1Yzk1MzU=

data/.gitignore

@@ -22,4 +22,6 @@ rack_warden.y*ml
 .DS_Store
 log/**
 scratch.rb
+/*.diff
 
+rack_warden_local_testing

data/Gemfile

@@ -3,15 +3,18 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in rack_warden.gemspec
 gemspec
 
+# To use edge sinatra, which should fix "NoMethodError: undefined method `join' for #<String:0x000001016a7c58>",
+# put this in your gemfile:
+#gem 'sinatra', git: 'git@github.com:sinatra/sinatra.git'
 
-# gem 'sinatra'
-# gem 'sinatra-flash', require: 'sinatra/flash'
-# gem 'bcrypt'
-# gem 'data_mapper'
-# gem 'dm-sqlite-adapter'
-# gem 'warden'
-# 
-# #gem 'shotgun'
-# #gem 'tux'
-# #gem 'thin'
+# Extra utilities that you might want.
+#gem 'shotgun'
+#gem 'tux'
+#gem 'thin'
 
+# If you have trouble with failing dependencies or templating errors in rails 2.3,
+# you may need to activate any or all of these.
+#gem "i18n", "0.6.11"
+#gem "mime-types", "~> 1.25"
+#gem "nokogiri", "1.5.11"
+#gem "erubis"

data/README.md

@@ -1,45 +1,50 @@
 # RackWarden
 
-RackWarden is a rack middleware mini-app that provides user authentication and management to any rack-based app (currently supports Sinatra and Rails, with more on the way). This project is in its infancy. It is currently a great starter to get you going with plug-in authentication for your ruby app. Over time it will grow into a more fully featured package while maintaining a focus on simplicity, modularity, and transparency.
+RackWarden is a ruby gatekeeper mini-app providing authentication and user management for rack based apps. Protecting your entire application with only a few lines of code, RackWarden uses its own controllers, views, models, and database. You can also drop in your own views and layouts, specify your own database, and use your existing users table for seamless custom integration.
 
-RackWarden uses Sinatra for the mini-app, Warden for authentication, and DataMapper for database connections. It is based on the sinatra-warden-example at https://github.com/sklise/sinatra-warden-example. If you are new to Warden or Sinatra, I highly recommend downloading and experimenting with that example.
+RackWarden is Rack middleware that uses Sinatra for UI, Warden for authentication, and DataMapper for database connections. It is based on the sinatra-warden-example at <https://github.com/sklise/sinatra-warden-example>.
 
-My goal in developing this software is to have drop-in authentication containing most of the features you see in user/account management sections of a typical web site. But I don't want to be strapped by this module in any of my projects, so it must be customizable. Or rather, overridable. The basics of this flexibility are already in place, and it will be a central theme throughout.
-
-Please note that RackWarden is a work-in-progress. The gemspec, the files, the code, and the documentation can and will change over time. Follow on github for the latest fixes, changes, and developments.
-
-## What Does it Do?
-
-RackWarden is a modular gatekeeper for your ruby web app. Once you enable RackWarden in your rack-based project, all routes/actions in your project will require a login and will redirect browsers to an authentication page. RackWarden provides its own view & layout templates to facilitate user authentication. RackWarden also provides it's own database & table structure to store user data. Views, layouts, databases, and tables are easily customized and/or overridden, however.
-
-Once RackWarden authenticates a user, it gets out of the way, and the user is returned to your application. RackWarden also provides a number of user management tools for common actions like creating, updating, and deleting users.
-
-Most of the RackWarden features can be customized. You can override the views, the database, the actions, and even the authentication logic with your own templates and code. The easiest (and possibly the most dramatic) customization is to provide RackWarden with your own layout template, giving RackWarden the appearane of the application you're integrating it with.
+RackWarden is a work-in-progress. The gemspec, the files, the code, and the documentation are likely to change over time. Follow on [rubygems.org](https://rubygems.org/gems/rack_warden) or [github](https://github.com/ginjo/rack_warden) for the latest updates.
 
 
 ## Installation
 
-In your Gemfile:
+In your Gemfile.
 
     gem 'rack_warden'
 
-Then:
+Then.
 
     $ bundle
 
-Or install manually:
+Or install manually.
 
     $ gem install rack_warden
 
+If you are using a database other than sqlite, and you want RackWarden to use that database as well, install the corresponding DataMapper database adapter. For sqlite, the dm-sqlite-adapter is already included in the RackWarden gemspec.
+
+    gem 'dm-mysql-adapter'
+    gem 'dm-postgres-adapter'
+    
+See the [DataMapper](https://github.com/datamapper/dm-core/wiki/Adapters) site for more info on adapters. 
 
 ## Usage
 
 A few simple steps will have your entire app protected.
+If not using bundler, don't forget to ```require 'rack_warden'```.
 
 ### Sinatra
 
+    # classic
+    register RackWarden
+
+    get "/" do
+      erb "All routes are now protected"
+    end    
+
+    # modular
     class MySinatraApp < Sinatra::Base
-      use RackWarden
+      register RackWarden
     
       get "/" do
         erb "All routes are now protected"
@@ -54,53 +59,96 @@ application.rb or environment.rb
     
     # All routes are now protected
     
+### Rack
+
+You can also use RackWarden with bare Rack applications. A ruby application framework is not necessary.
+
+config.ru
+
+    map "/" do
+      use RackWarden
+      run MyApp
+    end
 
 
 ## Configuration
 
-RackWarden will look for a configuration file named rack\_warden.yml in your project root or in your project/config/ directory. 
+RackWarden will look for a yaml configuration file named rack_warden.yml in your project root or in your project-root/config/ directory. You can specify any of RackWarden's settings here.
 
     ---
     database: sqlite3:///usr/local/some_other_database.sqlite3.db
     layout: :'my_custom_layout.html.erb'
 
 
-You an also pass configuration settings to RackWarden through the ```use``` method of your framework. The params hash of ```use``` will be translated directly to RackWarden's settings. In addition to RackWarden's specific configuration options, you can also pass in any standard Sinatra settings.
+You an also pass configuration settings to RackWarden through the ```use``` method of your framework. The params hash of ```use``` will be translated directly to RackWarden's settings. In addition to RackWarden's specific configuration options, you can also pass standard Sinatra settings.
 
-If you pass a block with the ```use``` method, the block will be evaluated in the context of the RackWarden::App class. Anything you do in that block is just as if you were writing code in the app class itself. While in the block, you also have access to the current instance of RackWarden::App.
+If you pass a block with the ```use``` method, the block will be evaluated in the context of the RackWarden::App class. Anything you do in that block is just as if you were writing code in the RackWarden::App class itself. While in the block, you also have access to the current _instance_ of RackWarden::App.
 
     use RackWarden::App do |rack_warden_app_instance|
-      set :somesetting, 'some_value'
+      set :some_setting, 'some_value'
     end
+
+You can also set RackWarden settings directly from inside your application.
+
+    RackWarden::App.set({:setting1 => val1, :setting2 => val2})
     
+Note that with some frameworks, the RackWarden middleware instance will be lazy-loaded only when it is needed (usually with the first request). This is a function of the ruby framework you are using and is not under control of RackWarden. This means that some settings you pass with the ```use``` method (or block) may have 'missed the boat'. RackWarden tries to integrate these settings in lazy-loaded situations as best as it can. However, if you suspect your settings might not be taking, put your settings in the rack\_warden.yml config file. The config file will always be loaded with the RackWarden module. If you are using Sinatra, load up RackWarden with ```register RackWarden```, as that will initialize RackWarden as soon as your Sinatra project loads.
+
 
 ## Configuration Options
 
 Current list of settings specific to rack\_warden, with defaults.
 
+    set :config_files, [ENV['RACK_WARDEN_CONFIG_FILE'], 'rack_warden.yml', 'config/rack_warden.yml'].compact.uniq
+    set :layout, :'rw_layout.html'
+    set :default_route, '/'
+    set :exclude_from_return_to, 'login|logout|new|create'
+    set :repository_name, :default
+    set :database_config => nil
+    set :database_default =>  "sqlite3:///#{Dir.pwd}/rack_warden.sqlite3.db"
+    set :recaptcha, Hash.new
+    set :require_login, nil
+    set :rack_authentication, nil
+    set :allow_public_signup, false
+    set :logging, true
+    set :log_path, "#{Dir.pwd}/log/rack_warden.#{settings.environment}.log"
+    set :use_common_logger, false
+    set :sessions, true
+    set :remember_token_cookie_name, 'rack_warden_remember_token'
+    set :user_table_name, 'rack_warden_users'
+    set :views, File.expand_path("../views/", __FILE__) unless views
+    set :login_on_create, true
+    set :login_on_activate, false
+    set :rw_prefix, '/auth'
+    set :mail_options,
+        :delivery_method => :test,
+        :delivery_options => {:from => 'my@email.com'}
+
+
+Some of the configuration settings in more detail.
+
 ### :layout
 
-A symbol representing a layout file in any of the view paths.
+A symbol representing a (Sinatra) layout file in any of the view paths.
     
     layout: :'rack_warden_layout.html'
     
 ### :default\_route
 
-A Sinatra route to fall back on after logout, errors, or any action that has no specified route.
+A Sinatra route to fall back on after logout, errors, or any redirect that has no specified route.
 
     default_route: '/'
     
 ### :database\_config
 
-A database specification hash or or url string.
+A database specification hash or url string.
 
     database_config: "sqlite:///Absolute/path/to/your/rack_warden.sqlite3.db"
     
     # or
     
     database_config: 
-      adapter: mysql2
-      encoding: utf8
+      adapter: mysql
       database: my_db_name
       username: root
       password: my_password
@@ -110,31 +158,30 @@ A database specification hash or or url string.
 ### :require\_login
 
 Parameters to pass to the before/before\_filter for require\_login.
-So if you're main app is Sinatra,
+So if your main app is Sinatra,
 
-    require_login: /^\/.+/
+    require_login: '/admin*'
     
 is the same as
 
     class MySinatraApp
-      require_login /^\/.+/
+      require_login '/admin*'
     end
     
 which is the same as
 
     class MySinatraApp
-      before /^\/.+/ do
+      before '/admin*' do
         require_login
       end
     end
     
 For Rails, you would be passing a hash of :only or :except keys.
 
-    require_login:
-      except: :index
+    require_login: {:except => [:index, :show]}
     
 The default for :require\_login is nil, which means require login on every route or action.
-To disable automatic activation of require\_login, pass it ```false```.
+To disable automatic activation of require\_login, set it to ```false```.
 
 ### :allow\_public\_signup
 
@@ -145,44 +192,54 @@ Allows public access to the account creation view & action.
     
 ### :recaptcha
 
-Settings for Google's recaptcha service
+Settings for Google's recaptcha service. If these settings exist, recaptcha will be required on account creation and password reset/recover actions.
 
     :recaptcha => {
       :sitekey => '',
       :secret  => ''
     }
 
-### :log\_path
 
-    File.join(Dir.pwd, 'log', 'rack_warden.log')
-    
-### :user\_table\_name
 
-    nil
-    
-### :views
+## Customization
 
-    File.expand_path("../views/", __FILE__)
+### Actions
 
+RackWarden adds a handful of helpers to your base controller class, giving you finer control over what actions (or routes) are protected. One of these helpers is ```require_login```. Run this helper in any action that you want protected behind a login session. If the user is not logged in, they will be redirected to the login action provided by RackWarden. Once they have successfully completed the login, the user will be redirected back to the protected page they were originally trying to access.
+
+The default for RackWarden is to enable the ```require_login``` helper on every action in your project. To disable this default, set ```:require_login``` (in your RackWarden configuration) to anything other than nil. Setting ```:require_login => false``` will disable automatic activation of the ```require_login``` helper entirely.
+
+To control authentication inclusion/exclusion of routes & actions on a per-controller or per-application basis, use the class method ```require_login```. This creates a before filter in the context where you declare it. You can pass any options to ```require_login``` that are allowed by your framework's before filter.
+
+  # Rails
+  class Products < ActionController::Base
+    require_login :only=>[:new, :create, :edit, :update]
+    ...
+  end
+  
+  # Sinatra
+  class MyApp < Sinatra::Base
+    require_login '/admin*', :agent => /Songbird/
+    ...
+  end
 
-## Customization
 
 ### Views
 
-To customize RackWarden for your specific project, you can set :views to point to a directory within your project. Then create templates that match the names of RackWarden templates, and they will be picked up and rendered. RackWarden looks for templates at the top level of your views directory and in views/rack\_warden (if it exists) as a default. You can change or add to this with the ```:views``` setting.
+RackWarden looks for templates at the top level of your views directory and in views/rack\_warden/ (if it exists) as a default. You can change or add to this with the ```:views``` setting.
 
     use RackWarden::App, :views => File.join(Dir.pwd, 'app/views/another_directory')
     
-Or if you simply want RackWarden to use your own custom layout, pass it a file path in the :layout parameter.
+Or if you simply want RackWarden to wrap all of its views in your own custom layout, pass it a file path in the :layout parameter.
 
     use RackWarden::App, :layout => :'layouts/rack_warden_layout.html'
     
-Just remember that RackWarden is Sinatra, and any templates you pass must use Sinatra-specific code. For example, Sinatra uses ```url``` instead of Rails' ```url_for```. Also remember that template names in Sinatra must always be symbols. Have a look at the readme on Sinatra's web site for more details on Sinatra's DSL.
+Remember that RackWarden is Sinatra, and any templates you pass must use Sinatra-specific code. For example, Sinatra uses ```url``` instead of Rails' ```url_for```. Also remember that template names in Sinatra must always be symbols. Have a look at the readme on Sinatra's web site for more details on Sinatra's DSL.
 
 
 ### Database
 
-As a default, RackWarden will use a sqlite3 in-memory database (that starts fresh each time you boot your app). To use the database specified in your project, just pass ```:auto``` to the ```:database_config``` setting. Pass ```:file``` to set up a sqlite3 database in your app's working directory. Or pass your own custom database specification (a url or hash). If you use a database other than sqlite3, you will need to include the respective DataMapper extension gems in your Gemfile or in your manually installed gem list. For MySQL, use dm-mysql-adapter, for Postgres use dm-postgres-adapter. See the DataMapper site for more info on database adapters.
+As a default, RackWarden will use a sqlite3 database created in your app's root. To use the database specified in your project, just pass ```:auto``` to the ```:database_config``` setting. Pass ```:file``` to set up a sqlite3 database in your app's working directory. Or pass your own custom database specification (a url or hash). If you use a database other than sqlite3, you will need to include the respective DataMapper extension gem in your Gemfile or in your manually installed gem list. For MySQL, use dm-mysql-adapter, for Postgres use dm-postgres-adapter. See the DataMapper site for more info on database adapters.
     
     # Database specification as a url
     database_config: 'sqlite3:///path/to/my/database.sqlite3.db'
@@ -190,12 +247,17 @@ As a default, RackWarden will use a sqlite3 in-memory database (that starts fres
     # Database specification as a hash
     database_config: {adapter: 'sqlite3', database: '/path/to/my/database.sqlite3.db'}
     
-		# Use a remote MySQL database
-		database_config: {adapter: 'mysql', username: 'will', password: 'mypass',
-			host: 'somehost', database: 'my_database'}
-		
-		# Format for database urls
-		#<adapter>://<username>:<password>@<host>:<port>/<database_name>
+    # Use a remote MySQL database
+    database_config: {adapter: 'mysql', username: 'will', password: 'mypass',
+      host: 'somehost', database: 'my_database'}
+    
+    # Format for database urls
+    #<adapter>://<username>:<password>@<host>:<port>/<database_name>
+
+#### A note about DataMapper and ActiveRecord
+
+ActiveRecord and DataMapper should be able to coexist in the same ruby process. Note that the database adapters for ActiveRecord are not the same as those for DataMapper. So for example, if you are using mysql, you will need the activerecord-mysql2-adapter for ActiveRecord (or mysql2 or mysql, if you're on older rails versions) and the dm-mysql-adapter for DataMapper.
+
 
 
 

data/config.ru

@@ -7,5 +7,6 @@ Bundler.require
 require File.expand_path('../lib/rack_warden', __FILE__)
 
 map ENV['BASE_URI'] || '/' do
+	RackWarden::App.set :sessions, :key=>'_rack_warden'
 	run RackWarden::App
 end

data/lib/rack_warden.rb

@@ -6,25 +6,42 @@ module RackWarden
 end
 
 require "sinatra/base"
-require "sinatra/flash"
+#require "sinatra/contrib" # not compatible with rails 2.3 because of rack dependency conflict.
+require "rack/flash" # this somehow loads rack/flash3
+require "rack/contrib/cookies"  # This is needed to set cookies in warden callbacks.
 require 'bcrypt'
 require 'data_mapper'
 require 'warden'
-require 'open-uri'
 require 'yaml'
+require 'tilt/erb'  # An error somwhere suggested this be explicity required.
+require 'rack_warden/core_patches'
+
+autoload :Mail, 'mail'
+autoload :URI, 'open-uri'
+autoload :Base64, 'base64'
 
 module RackWarden
   autoload :App, 'rack_warden/app'
+  autoload :Env, 'rack_warden/env'
   autoload :User, "rack_warden/models"
   autoload :Pref, "rack_warden/models"
+  autoload :Mail, "rack_warden/mail"
   autoload :Routes, "rack_warden/routes"
   autoload :VERSION, "rack_warden/version"
   autoload :WardenConfig, "rack_warden/warden"
+  autoload :AppClassMethods, "rack_warden/helpers"
+  autoload :UniversalHelpers, "rack_warden/helpers"
   autoload :RackWardenHelpers, "rack_warden/helpers"
+  # Autload patched versions of respond_with & namespace.
+  # respond_with handles uri dot-format extension,
+  # and namespace handles require_login.
+  autoload :RespondWith, "rack_warden/sinatra/respond_with"
+  autoload :Namespace, "rack_warden/sinatra/namespace"
+  autoload :Frameworks, "rack_warden/frameworks"
   module Frameworks
-    autoload :Base, 'rack_warden/frameworks'
     autoload :Sinatra, 'rack_warden/frameworks/sinatra'
     autoload :Rails, 'rack_warden/frameworks/rails'
+    autoload :Rack, 'rack_warden/frameworks/rack'
   end
   
   # Make this module a pseudo-class appropriate for middlware stack. Use RackWarden for older rails apps (rather than 'RackWarden::App')
@@ -50,8 +67,19 @@ module RackWarden
 	end
 	
 	def self.included(base)
-		puts "RW self.included into BASE #{base}, ID #{base.object_id}"
-		App.new base
+		App.logger.warn "RW self.included into BASE #{base}, ID #{base.object_id}"
+		# Force initialize rack_warden, even if not all the settings are known yet.
+		#App.new base
+	end
+	
+	def self.registered(app)
+		App.setup_framework app
+		# TODO: Do we need to check installed middleware to make sure we only have one instance of RW,
+		# in case someone registers RW with multiple sinatra apps in the same ruby process (which seems to be a common practice)?
+		app.use self
 	end
+	
+	# Enable this for automatic sinatra top-level registration.
+	#Sinatra.register self
   
 end

data/lib/rack_warden/app.rb

@@ -1,49 +1,47 @@
 # require 'bundler'
 # Bundler.require
 
+require 'logger'
+
 module RackWarden
   class App < Sinatra::Base
-        
+          
     set :config_files, [ENV['RACK_WARDEN_CONFIG_FILE'], 'rack_warden.yml', 'config/rack_warden.yml'].compact.uniq
     set :layout, :'rw_layout.html'
     set :default_route, '/'
-    set :database_config => nil  #, "sqlite3:///#{Dir.pwd}/rack_warden.sqlite3.db"
-    set :database_default => "sqlite3::memory:"   #"sqlite3:///#{Dir.pwd}/rack_warden.sqlite3.db"
+    set :exclude_from_return_to, 'login|logout|new|create'
+    set :repository_name, :default
+    set :database_config => nil
+    set :database_default =>  "sqlite3:///#{Dir.pwd}/rack_warden.sqlite3.db"
     set :recaptcha, Hash.new
     set :require_login, nil
+    set :rack_authentication, nil
     set :allow_public_signup, false
+    set :logging, true
     set :log_path, "#{Dir.pwd}/log/rack_warden.#{settings.environment}.log"
-    set :user_table_name, nil
+    set :log_file, ($0[/rails|irb|ruby|rack|server/i] && development? ? $stdout : nil)
+    set :log_level => ENV['RACK_WARDEN_LOG_LEVEL'] || (development? ? 'INFO' : 'WARN')
+    set :logger, nil
+    set :use_common_logger, false
+    set :reset_logger, false
+    set :sessions, true # Will use parent app sessions. Pass in :key=>'something' to enable RW-specific sessions (maybe).
+    set :remember_token_cookie_name, 'rack_warden_remember_token'
+    set :user_table_name, 'rack_warden_users'
     set :views, File.expand_path("../views/", __FILE__) unless views
     set :initialized, false
+    set :login_on_create, true
+    set :login_on_activate, false
+    set :rw_prefix, '/auth'
+    set :mail_options,
+    		:delivery_method => :test,
+    		:delivery_options => {:from => 'my@email.com'} #, :openssl_verify_mode => OpenSSL::SSL::VERIFY_NONE
+
     
-    # Load config from file, if any exist.
-    Hash.new.tap do |hash|
-      config_files.each {|c| hash.merge!(YAML.load_file(File.join(Dir.pwd, c))) rescue nil}
-      set hash
-    end
-    
-    
-    
-    enable :sessions
-    register Sinatra::Flash
-    
-		begin
-	    enable :logging
-	    set :log_file, File.new(settings.log_path, 'a+')
-	    settings.log_file.sync = true
-	    use Rack::CommonLogger, settings.log_file
-	  rescue
-	  end
 	  
-		include RackWarden::WardenConfig
-		include RackWarden::Routes
+		register AppClassMethods
 		
-    helpers RackWardenHelpers
-    helpers UniversalHelpers
-  
-  
   
+
     # WBR - This will receive params and a block from the parent "use" statement.
     # This middleware app has been modified to process the parent use-block in
     # the context of the RackWarden class. So you can set settings on RackWarden,
@@ -54,40 +52,30 @@ module RackWarden
   	# 	set :myvar, 'something'
   	#	end
   	#
+  	# TODO: Move most of this functionality to a class method, so it can be called from self.registered(app)
   	def initialize(parent_app_instance=nil, *args, &block)
   		super(parent_app_instance, &Proc.new{}) # Must send empty proc, not original proc, since we're calling original block here.
   	  initialization_args = args.dup
-  		puts "RW new instance with parent: #{@app}"
-  		# extract options.
+  		logger.info "RW new app instance with parent: #{@app}"
   		opts = args.last.is_a?(Hash) ? args.pop : {}
+  		
+  		
+  		
   		if app && !settings.initialized
-  		  puts "RW initializing settings"
+  		  logger.warn "RW initializing settings from app instance"
   		  
-  			# Save original views from opts.
-  			#settings.set(:original_views, opts.has_key?(:views) ? settings.views : nil)
-  			settings.set(:original_views, settings.views)
-
-  			# Set app settings with remainder of opts.
-  			settings.set opts if opts.any?
-  			
+  		  self.class.setup_framework(parent_app_instance, *initialization_args) #unless Frameworks.selected_framework
+    		    		
   			# Eval the use-block from the parent app, in context of this app.
   			settings.instance_exec(self, &block) if block_given?
   			
-  			# Do framework setup.
-  			framework_module = Frameworks::Base.select_framework(binding)
-    		puts "RW selected framework module #{framework_module}"
-    		if framework_module
-      		framework_module.setup_framework
-        
-          # Manipulate views
-      		new_views = []
-      		new_views.unshift settings.original_views
-      		new_views.unshift framework_module.views_path unless settings.views==false
-      		new_views.unshift settings.views
-      		settings.set :views, new_views.flatten.compact.uniq
-      		
-      		puts "RW compiled views: #{settings.views.inspect}"
-    		end
+ 		    # Set global layout (remember to use :layout=>false in your calls to partials).
+		    settings.set :erb, :layout=>settings.layout
+  			
+  			settings.initialize_logging
+  			  			
+  			logger.info "RW compiled views: #{settings.views.inspect}"
+    		
     		settings.set :initialized, true
   		end
 
@@ -95,14 +83,41 @@ module RackWarden
   	
 		# Store this app instance in the env.
 		def call(env)  
-			#puts "RW instance.app #{app}"
-		  #puts "RW instance.call(env) #{env.to_yaml}"
-		  env['rack_warden_instance'] = self
-		  super(env)
+			logger.debug "RW app.call extending env with Env."
+			env.extend Env
+			logger.debug "RW app.call next app: #{@app}"
+		  
+		  # Set this now, so you can access the rw app instance from the endpoint app.
+		  logger.debug "RW app.call storing app instance in env['rack_warden_instance'] #{self}"
+		  self.request= Rack::Request.new(env)
+		  env.rack_warden = self
+			
+			# Authenticate here-and-now.		  
+		  if !request.path_info.to_s.match(/^\/auth/) && settings.rack_authentication
+		  logger.debug "RW rack_authentication for path_info: #{request.path_info}"
+		  Array(settings.rack_authentication).each do |rule|
+		  	logger.debug "RW rack_authentication rule #{rule}"
+		  	(require_login) if rule && request.path_info.to_s.match(Regexp.new rule.to_s)
+		  end
+		  end
+		  
+		  # Send to super, then build & process response.
+			# resp = Rack::Response.new *super(env).tap{|e| e.unshift e.pop}
+			# #resp.set_cookie :wbr_cookie, :value=>"Yay!", :expires=>Time.now+60*10
+			# logger.debug "App.call: #{resp.finish}"
+			# resp.finish
+			super(env)
 		end 
+		
+		# Only initialize app after all above have loaded.
+		#initialize_app_class
 
 
-  end # App 
+  end # App
+  
+  # TODO: This is not working:
+  #Sinatra::Application.register self
 end # RackWarden
 
 
+