authlane 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5d433f29ea95649c1f3c82327cdf25585028d774
+  data.tar.gz: 4a2e2944a3a75b5d263ecbf74cbc55e3327df5e0
+SHA512:
+  metadata.gz: 070797815dead62c30f657efc56c5dfb3abdf8f0c792d68062469dcb67de9480907b204391a62b2a48bcf85e08f18e017b290fda9787bc0b3f6bd29bf762a280
+  data.tar.gz: f2191d60b1b6f4e4f6acdf7f393c9e9bbf375a7214edd0ff986f2183f4f7f513c9bb4e8508ddb73355b6491007c9ac41528a77dcbdc80e86b93bb02e0b12417c

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.yardopts

@@ -0,0 +1 @@
+--no-private --main=README.md --markup=markdown lib/**/*.rb

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in gembootstrap.gemspec
+gemspec

data/LICENSE.md

@@ -0,0 +1,22 @@
+Copyright (c) 2014-2015 Patrick Lam
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,38 @@
+# AuthLane
+
+The **AuthLane** Sinatra Extension allows easy User authentication with support for different User *roles* and automatic login via Cookies. It exposes Helper methods to tell which routes are protected or involved in the authentication process.
+
+The actual authentication logic (*strategy*) is defined by the Application using a namespaced DSL provided by this extension, while the general Extension configuration is handled with Sinatra's `set` method, which will be described in more detail below.
+
+# Configuring *AuthLane*
+
+**AuthLane**'s configuration data is available under Sinatra's `settings` object with the key `:authlane` as a Hash, so changing config values is simply done with Sinatra's `set` method.
+
+```
+set :authlane, :failed_route => '/login'
+```
+
+The following settings can be customize (the used values are their defaults):
+
+```
+set :authlane, :failed_route    => '/user/unauthorized',
+              :session_key     => :authlane,
+              :remember_cookie => :authlane_token,
+              :serialize_user  => [:id]
+```
+
+### `:failed_route`
+
+The `:failed_route` sets the route String, where AuthLane should redirect to in case a route requires authorisation and the User ist not logged in. It typically is the route to display the login form, but can be set to anything that is needed, as long the it is not protected by authorisation as well.
+
+### `:seession_key`
+
+The `:session_key` sets the name (as a Symbol) of the Session variable where User credentials of a logged in User are stored. The stored User data are wrapped inside a `SerializedUser` object and can be retrieved by using Sinatra's `session` helper and giving it the key that is defined here `session[:authlane]`. Alternatively, the AuthLane Helper exposes the method `current_user` to provide easy access to User data.
+
+### `:remember_cookie`
+
+Customize the Cookie's name that stores the token hash used for the *Remember Me* functionality. The setting (and creation) of the token needs to be implemented by the Extension user in both the Auth and Remember Strategy.
+
+### `:serialize_user`
+
+The `:serialized_user` settings contains an Array of Symbols telling AuthLane which attributes of the User model that is used to identify Application useres should be serialized into `SerializedUser`. It is recommended to not store the whole User object, but note that the *id* (or however the unique identifier of the object is named) attribute is required.

data/Rakefile

@@ -0,0 +1,26 @@
+require 'authlane/version'
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+namespace :doc do
+  desc 'Generate YARD documentation database'
+  task :generate do
+    system 'rm -rf .yardoc'
+    system 'yardoc'
+  end
+
+  desc 'Start the YARD documentation server'
+  task :srv do
+    system 'yard server --reload -- Kargo'
+  end
+
+  desc 'Open generated YARD documentation website'
+  task :open do
+    system 'open doc/index.html'
+  end
+end
+
+RSpec::Core::RakeTask.new(:spec)
+
+Dir['tasks/*.rake'].sort.each { |ext| load ext }

data/authlane.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'authlane/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'authlane'
+  spec.version       = Authlane::VERSION
+  spec.authors       = ['Patrick Lam']
+  spec.email         = ['zidizei@gmail.com']
+  spec.summary       = 'Easy User authentication and roles for Sinatra.'
+  spec.description   = 'The AuthLane Sinatra Extension allows easy User authentication with support for different User roles.'
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(/^(test|spec|features)\//)
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'sinatra'
+  spec.add_dependency 'sinatra-contrib'
+
+  spec.add_development_dependency 'bundler', '~> 1.5'
+  spec.add_development_dependency 'rake', '~> 10.1'
+  spec.add_development_dependency 'rspec', '~> 2.6'
+  spec.add_development_dependency 'yard'
+end

data/lib/authlane/helper.rb

@@ -0,0 +1,191 @@
+
+module Sinatra
+  module AuthLane
+    ##
+    # The **AuthLane** `Helpers` are helper methods that are made available to an application's
+    # route definitions. It is the main interface between a Sinatra Application and AuthLane
+    # and enables easy interaction with the authorization logic by calling a specific helper method.
+    #
+    module Helpers
+      ##
+      # @note This method uses {#authorized?} to decide, whether to redirect users to `failed_route`.
+      # Check if a user is authorized to view a route.
+      #
+      # It utilizes the *Role* and *Remember Strategy* to see if a user can access the route this
+      # helper method is called from. The first query inside this method is to look for logged in
+      # user credentials in the Session. If this fails, *AuthLane* attempts to login the user
+      # via Cookie token by calling the *Remember Strategy* that is defined for the application. If it succeeds,
+      # this method will continue normally (as in the user was already logged in 'regularly') and
+      # use the *Role Strategy* to check user privileges for the route, in case there were any specified when
+      # it was being called.
+      #
+      # @example
+      #   get '/account' do
+      #     protect!
+      #
+      #     mustache :account
+      #   end
+      #
+      #   get '/admin' do
+      #     protect! roles: [:Admin],
+      #              failed_route: '/account'
+      #
+      #     mustache :admin
+      #   end
+      #
+      # @param [Array] roles A list of role/privilege requirements for a route, set to `nil` to ignore user roles
+      # @param [String] failed_route Custom route to redirect to in case the user is not authorized
+      #
+      # @see Sinatra::AuthLane.create_role_strategy create_role_strategy
+      # @see Sinatra::AuthLane.create_remember_strategy create_remember_strategy
+      #
+      def protect!(roles: nil, failed_route: nil)
+        # check for custom :failed_route option
+        failed_route ||= settings.authlane[:failed_route]
+
+        redirect failed_route unless authorized?(roles: roles)
+      end
+
+      alias_method :protected, :protect!
+
+      ##
+      # @note For more information about how this method works, refer to {#protect!}.
+      #
+      # Returns a `Boolean` depending on the user's authorization status. This can be useful if
+      # a route wants to handle unauthorized users differently than just redirecting them to the
+      # `:failed_route` setting.
+      #
+      # @example
+      #   get '/' do
+      #     if authorized?
+      #       mustache :welcome
+      #     else
+      #       mustache :whoareyou
+      #     end
+      #   end
+      #
+      # @param [Array] roles A list of role/privilege requirements for a route, set to `nil` to ignore user roles
+      #
+      # @return [Boolean] `true` if the user is authorized to view a route, `false` otherwise.
+      #
+      # @see Sinatra::AuthLane::Helpers#protect! protect!
+      #
+      def authorized?(roles: nil)
+        # So, if session[settings.authlane[:session_key]] is available
+        # we're home, otherwise, see if the 'Remember Me' strategy
+        # can come up with some User credentials.
+        if session[settings.authlane[:session_key]].nil?
+          remember_strat = self.instance_eval(&settings.authlane[:remember_strategy])
+
+          if remember_strat
+            user = Sinatra::AuthLane::SerializedUser.new(remember_strat, settings.authlane[:serialize_user])
+
+            # The strategy doesn't log in a User,
+            # it just comes up with the credentials to do that.
+            # The login actually happens right here.
+            session[settings.authlane[:session_key]] = user
+          end
+        else
+          user = session[settings.authlane[:session_key]]
+        end
+
+        if user.nil? || !user
+          # Ok, looks like the User needs to gtfo.
+          return false
+        else
+          # User is logged in ...
+          unless roles.nil?
+            # ... but hold up, he might not have the necessary
+            # privileges to access this particular route.
+            # Let's ask the 'Role' strategy.
+            strat = self.instance_exec roles, &settings.authlane[:role_strategy]
+            return false unless strat
+          end
+        end
+
+        return true
+      end
+
+      ##
+      # Marks a route as the login route, that typically receives `POST` data from a `<form>`.
+      #
+      # The actual handling of the login logic and anything else the application
+      # requires is defined by creating the *Auth Strategy* using {Sinatra::AuthLane.create_auth_strategy create_auth_strategy}.
+      # the code block will be called within `authorize!` and - depending on the outcome (refer to
+      # {Sinatra::AuthLane.create_auth_strategy create_auth_strategy}'s documentation of its return value) - redirects
+      # to the `:failed_route` AuthLane setting or lets the user 'through' to access the route, which - in most cases - should
+      # be a redirect to the protected route.
+      #
+      # @example
+      #   get '/signin' do
+      #     mustache :signin
+      #   end
+      #
+      #   post '/signin' do
+      #     authorize!
+      #
+      #     redirect '/account'
+      #   end
+      #
+      # @return [void]
+      #
+      # @see Sinatra::AuthLane.create_auth_strategy create_auth_strategy
+      #
+      def authorize!
+        strat = self.instance_exec &settings.authlane[:auth_strategy]
+
+        unless strat
+          redirect settings.authlane[:failed_route], 303
+        end
+
+        session[settings.authlane[:session_key]] = Sinatra::AuthLane::SerializedUser.new(strat, settings.authlane[:serialize_user])
+      end
+
+      ##
+      # Marks a route as the logout route.
+      #
+      # It resets the current Session and deletes any Session data along with it, particularly
+      # the *AuthLane* Session data. The *Forget Strategy* will be called here as well to
+      # 'counteract' the *Remember Me* functionality that is implemented in the *Remember* and
+      # *Auth Strategy*.
+      #
+      # @example
+      #   get '/signout' do
+      #     unauthorize!
+      #   end
+      #
+      # @return [void]
+      #
+      # @see Sinatra::AuthLane.create_forget_strategy create_forget_strategy
+      #
+      def unauthorize!
+        token = cookies[settings.authlane[:remember_cookie]]
+
+        self.instance_exec(token, &settings.authlane[:forget_strategy]) unless token.nil?
+
+        # @private
+        cookies.delete(settings.authlane[:remember_cookie])
+        session.destroy
+      end
+
+      ##
+      # Gets the credentials of the currently logged in user.
+      #
+      # @example
+      #   get '/account' do
+      #     authorized?
+      #
+      #     @username = current_user.username
+      #     @email    = current_user[:email]    # This works too (refer to SerializedUser for more info)
+      #
+      #     mustache :account
+      #   end
+      #
+      # @return [SerializedUser] the user data serialized into the Session.
+      #
+      def current_user
+        session[settings.authlane[:session_key]]
+      end
+    end
+  end
+end

data/lib/authlane/serializeduser.rb

@@ -0,0 +1,85 @@
+
+module Sinatra
+  module AuthLane
+    ##
+    # Storage class for logged in user credentials.
+    # Behaves like a Hash **and** an Object.
+    #
+    class SerializedUser
+      ##
+      # Sets up the Object to be serialized.
+      #
+      # Receives an Object `user` and stores its
+      # attributes specified by `attributes` in a Hash.
+      # If `attributes` is empty, the whole object
+      # will be stored as-is.
+      #
+      # @param [Object] user The User object that needs to be serialized
+      # @param [Array<Symbol>] attributes A list of attribute names to be serialized from `user`
+      #
+      def initialize(user, attributes = [])
+        if attributes.size == 0
+          @user = user
+        else
+          @user = Hash.new
+
+          attributes.each do |attrs|
+            @user[attrs] = user.__send__(attrs.to_sym) if user.respond_to? attrs
+          end
+        end
+      end
+
+      ##
+      # Access stored attributes like a Hash.
+      #
+      # If the whole Object was stored, it sends the
+      # Hash key `a` as a message to that Object.
+      #
+      # @param [String, Symbol] a The name of the serialized object's attribute to be read
+      #
+      def [](a)
+        (@user.is_a? Hash) ? @user[a] : @user.__send__(a.to_sym)
+      end
+
+      ##
+      # Enables Object-like access to the
+      # stored attributes.
+      #
+      # If the whole Object was stored, it sends the
+      # method name `m` as a message to that Object.
+      # Otherwise it will access the Hash using `m` as
+      # the key.
+      #
+      # @param [Symbol] m The name of the serialized object's attribute to be read
+      #
+      def method_missing(m, *args, &block)
+        if @user.is_a? Hash
+          @user[m]
+        else
+          @user.__send__(m.to_sym, args)
+        end
+      end
+
+      ##
+      # Return a Hash representing the serialized object's attributes and values.
+      #
+      # If the whole Object was stored its `to_h` will be called.
+      # In either case, attribute names can be accessed by Symbol or String
+      # key alike.
+      #
+      # @return [Hash] the Hash representation of the stored object.
+      #
+      def to_h
+        universal_hash = Hash.new
+        hash = @user.to_h
+        hash.each_pair do |key, value|
+          universal_hash[key.to_s] = value if key.is_a? Symbol
+
+          universal_hash[key] = value
+        end
+
+        universal_hash
+      end
+    end
+  end
+end

data/lib/authlane/version.rb

@@ -0,0 +1,6 @@
+
+module Authlane
+  ##
+  # Current AuthLane version number.
+  VERSION = '1.0.0'
+end

data/lib/sinatra/authlane.rb

@@ -0,0 +1,229 @@
+require 'sinatra/base'
+require 'sinatra/cookies'
+
+require 'authlane/version'
+require 'authlane/serializeduser'
+require 'authlane/helper'
+
+module Sinatra
+  ##
+  # The `AuthLane` Sinatra Extension allows easy User
+  # authentication with support for different User *roles*
+  # and automatic login via Cookies. It exposes {Sinatra::AuthLane::Helpers Helper}
+  # methods to tell which routes are protected or involved in the authentication process.
+  #
+  # The actual authentication logic (*strategy*) is defined by the Application using
+  # a namespaced DSL provided by this extension, while the general Extension configuration
+  # is handled with Sinatra's `set` method, which will be described in more detail below.
+  #
+  # # Configuring AuthLane
+  #
+  # **AuthLane**'s configuration data is available under Sinatra's `settings` object
+  # with the key `:authlane` as a Hash, so changing config values is simply done with
+  # Sinatra's `set` method.
+  #
+  # ```
+  # set :authlane, :failed_route => '/login'
+  # ```
+  #
+  # The following settings can be customize (the used values are their defaults):
+  #
+  # ```
+  # set :authlane, :failed_route    => '/user/unauthorized',
+  #                :session_key     => :authlane,
+  #                :remember_cookie => :authlane_token,
+  #                :serialize_user  => [:id]
+  # ```
+  #
+  # ## `:failed_route`
+  #
+  # The `:failed_route` sets the route String, where AuthLane should redirect to in case a
+  # route requires authorisation and the User ist not logged in. It typically is the route
+  # to display the login form, but can be set to anything that is needed, as long the it is
+  # not protected by authorisation as well.
+  #
+  # ## `:seession_key`
+  #
+  # The `:session_key` sets the name (as a Symbol) of the Session variable where User credentials of a logged in
+  # User are stored. The stored User data are wrapped inside a {Sinatra::AuthLane::SerializedUser SerializedUser}
+  # object and can be retrieved by using Sinatra's `session` helper and giving it the key that is defined here
+  # `session[:authlane]`. Alternatively, the AuthLane {Sinatra::AuthLane::Helpers Helper} exposes the method
+  # {Sinatra::AuthLane::Helpers#current_user current_user} to provide easy access to User data.
+  #
+  # ## `:remember_cookie`
+  #
+  # Customize the Cookie's name that stores the token hash used for the *Remember Me* functionality.
+  # The setting (and creation) of the token needs to be implemented by the Extension user in
+  # both the Auth and Remember Strategy.
+  #
+  # ## `:serialize_user`
+  #
+  # The `:serialized_user` settings contains an Array of Symbols telling AuthLane which attributes
+  # of the User model that is used to identify Application useres should
+  # be serialized into {Sinatra::AuthLane::SerializedUser SerializedUser}. It is recommended to not
+  # store the whole User object, but note that the *id* (or however the unique identifier
+  # of the object is named) attribute is required.
+  #
+  module AuthLane
+    ##
+    # Initiates **AuthLane** when it is being registered with a Sinatra Application.
+    #
+    # Adds helper methods to App instance and sets the default
+    # settings described above.
+    #
+    # @todo Don't pass `app` to instance variable `@app`. Implement proper encapsulation of AuthLane.
+    #
+    # @api Sinatra
+    #
+    def self.registered(app)
+      app.helpers AuthLane::Helpers
+
+      @app = app
+
+      # default configuration
+      app.set :authlane,
+        :failed_route      => '/user/unauthorized',   # route to redirect to if the user is required to login
+        :session_key       => :authlane,              # name of the Session key to store the login data
+        :remember_cookie   => :authlane_token,        # Cookie name to store 'Remember Me' token
+        :auth_strategy     => Proc.new { false },     # strategy to be executed to log in users
+        :role_strategy     => Proc.new { true },      # strategy to be executed to check permissions and roles
+        :remember_strategy => Proc.new { false },     # strategy to be executed to log in users via 'Remember Me' token
+        :forget_strategy   => Proc.new { false },     # strategy to be executed when logging out and 'forgetting' the user
+        :serialize_user    => [:id]                   # specify User model fields to be serialized into the login session
+    end
+
+    class << self
+      ##
+      # Create the **Auth** *Strategy* for AuthLane.
+      #
+      # Used from the Sinatra DSL context to define the **Auth** *Strategy*
+      # to be used by passing the implementation as a Code block. It is then
+      # stored as a `Proc` object and will be called by AuthLane when needed.
+      #
+      # The following describes the `Proc` objects API requirements. It is
+      # required by the implemented strategy to follow these to be usable by AuthLane.
+      #
+      # @note While the **Auth** Strategy is primarily responsible for logging in users,
+      #   it usually needs to implement some *Remember Me* logic as well.
+      #
+      # @return [False, Object] The strategy needs to return the User Model object of
+      #   the user that successfully logged in or - in case of failure - `false`.
+      #
+      # @example
+      #   Sinatra::AuthLane.create_auth_strategy do
+      #     user = User.find_by_username(params[:username])
+      #
+      #     (!user.nil? && user.password == params[:pass]) ? user : false
+      #   end
+      #
+      # @see Sinatra::AuthLane::Helpers#authorize! authorize!
+      #
+      # @api AuthLane
+      #
+      def create_auth_strategy
+        @app.set :authlane, :auth_strategy => Proc.new
+      end
+
+      ##
+      # Create the **Role** *Strategy* for AuthLane.
+      #
+      # Used from the Sinatra DSL context to define the **Role** *Strategy*
+      # to be used by passing the implementation as a Code block. It is then
+      # stored as a `Proc` object and will be called by AuthLane when needed.
+      #
+      # The following describes the `Proc` objects API requirements. It is
+      # required by the implemented strategy to follow these to be usable by AuthLane.
+      #
+      # @example
+      #   Sinatra::AuthLane.create_role_strategy do |roles|
+      #     user = current_user         # AuthLane helper to get the currently logged in user data
+      #
+      #     roles.include? user.role    # See if the list of role names in `roles` contains the user's role
+      #   end
+      #
+      # @param [Array] roles The `Proc` receives a list of role names (e.g. as Symbols) a User needs to fullfill
+      #   to be allowed to see the route. The list is passed by the {Sinatra::AuthLane::Helpers#authorized? authorized?}
+      #   helper.
+      #
+      # @return [Boolean] The strategy returns `true`, if the user met the necessary role requirements or `false` otherwise.
+      #
+      # @see Sinatra::AuthLane::Helpers#authorized? authorized?
+      #
+      # @api AuthLane
+      #
+      def create_role_strategy
+        @app.set :authlane, :role_strategy => Proc.new
+      end
+
+      ##
+      # Create the **Remember** *Strategy* for AuthLane.
+      #
+      # Used from the Sinatra DSL context to define the **Remember** *Strategy*
+      # to be used by passing the implementation as a Code block. It is then
+      # stored as a `Proc` object and will be called by AuthLane when needed.
+      #
+      # The following describes the `Proc` objects API requirements. It is
+      # required by the implemented strategy to follow these to be usable by AuthLane.
+      #
+      # @note The **Remember** Strategy is only responsible for automatically logging in a user.
+      #   The necessary Cookie token (or whatever technique) is usually set in the **Auth** Strategy.
+      #
+      # @example
+      #   Sinatra::AuthLane.create_remember_strategy do
+      #     remember_token  = cookies[:authlane_token]
+      #     remembered_user = User.find_by_token(remember_token)
+      #
+      #     (remembered_user.nil?) ? false : remembered_user
+      #   end
+      #
+      # @return [False, Object] The strategy needs to return the User Model object of
+      #   the user that successfully logged in or - in case of failure - `false`.
+      #
+      # @see Sinatra::AuthLane::Helpers#authorized? authorized?
+      #
+      # @api AuthLane
+      #
+      def create_remember_strategy
+        @app.set :authlane, :remember_strategy => Proc.new
+      end
+
+      ##
+      # Create the **Forget** *Strategy* for AuthLane.
+      #
+      # Used from the Sinatra DSL context to define the **Forget** *Strategy*
+      # to be used by passing the implementation as a Code block. It is then
+      # stored as a `Proc` object and will be called by AuthLane when needed.
+      #
+      # The following describes the `Proc` objects API requirements. It is
+      # required by the implemented strategy to follow these to be usable by AuthLane.
+      #
+      # @note The **Forget** Strategy is the counter-part to the **Remember** Strategy.
+      #   It's responsible for disabling the auto login technique and is called when logging out.
+      #
+      # @note While the *Auth* and *Remember Strategy* needs to interact with the Cookie token directly,
+      #   the *Forget Strategy* does not need to implement the deletion of the Cookie.
+      #   This is done automatically by AuthLane behind the scenes.
+      #
+      # @example
+      #   Sinatra::AuthLane.create_forget_strategy do |token|
+      #     user = User.find(current_user.id)
+      #     user.token = nil if user.token == token
+      #   end
+      #
+      # @param [Object] token The `Proc` object receives the *Remember Me* token of the current user.
+      #
+      # @see Sinatra::AuthLane::Helpers#unauthorize! unauthorize!
+      #
+      # @return [void]
+      #
+      # @api AuthLane
+      #
+      def create_forget_strategy
+        @app.set :authlane, :forget_strategy => Proc.new
+      end
+    end
+  end
+
+  helpers Sinatra::Cookies
+  register Sinatra::AuthLane
+end

data/spec/authlane_helper_spec.rb

@@ -0,0 +1,77 @@
+require File.expand_path '../helper.rb', __FILE__
+
+describe Sinatra::AuthLane::Helpers do
+  before :all do
+    mock_app do
+      helpers Sinatra::Cookies
+      register Sinatra::AuthLane
+
+      use Rack::Session::Cookie, :secret => 'rspec'
+
+      Sinatra::AuthLane.create_auth_strategy { { id: 1 } }
+
+      get '/protected' do
+        protect!
+      end
+
+      get '/authorized' do
+        if authorized?
+          'authorized'
+        else
+          'unauthorized'
+        end
+      end
+
+      get '/authorize' do
+        authorize!
+        protect!
+      end
+
+      get '/unauthorize' do
+        unauthorize!
+        protect!
+      end
+
+      get '/user' do
+        protect!
+        user = current_user
+        user
+      end
+    end
+  end
+
+  it "should be able to recognize authorized states" do
+    get '/authorized', {}, { 'rack.session' => { authlane: { id: 1 } } }
+    expect(last_response.body).to eq('authorized')
+  end
+
+  it "should be able to recognize unauthorized states" do
+    get '/authorized'
+    expect(last_response.body).to eq('unauthorized')
+  end
+
+  it "should redirect from protected route to signin page when not logged in" do
+    get '/protected'
+    expect(last_response.headers['location']).to eq('http://example.org/user/unauthorized')
+  end
+
+  it "should display protected route when logged in" do
+    get '/protected', {}, { 'rack.session' => { authlane: '1' } }
+    last_response.should be_ok
+  end
+
+  it "should authorize a User" do
+    get '/authorize'
+    last_response.should be_ok
+  end
+
+  it "should unauthorize a User" do
+    get '/unauthorize', {}, { 'rack.session' => { authlane: '1' } }
+    expect(last_response.headers['location']).to eq('http://example.org/user/unauthorized')
+  end
+
+  it "should be able to get the current User's serialized credentials" do
+    get '/user', {}, { 'rack.session' => { authlane: '1' } }
+    expect(last_response.body).to eq('1')
+  end
+end

data/spec/authlane_serializeduser_spec.rb

@@ -0,0 +1,38 @@
+require File.expand_path '../helper.rb', __FILE__
+
+describe Sinatra::AuthLane::SerializedUser do
+  def mock_user
+    Sinatra::AuthLane::SerializedUser.new({ id: 1, name: 'rspec' })
+  end
+
+  it 'can be accessed like a Hash' do
+    user = mock_user
+    user.should respond_to(:[])
+    user[:id].should eql(1)
+    user[:name].should eql('rspec')
+  end
+
+  it 'can be accessed like an Object' do
+    user = mock_user
+    user.should respond_to(:method_missing)
+    user.id.should eql(1)
+    user.name.should eql('rspec')
+  end
+
+  it 'should return Hash of the serialized User object' do
+    user = mock_user
+    user.to_h.should be_a(Hash)
+  end
+
+  it 'should return Hash of the serialized User object with String keys' do
+    user = mock_user.to_h
+    user['id'].should eql(1)
+    user['name'].should eql('rspec')
+  end
+
+  it 'should return Hash of the serialized User object with Symbol keys' do
+    user = mock_user.to_h
+    user[:id].should eql(1)
+    user[:name].should eql('rspec')
+  end
+end

data/spec/helper.rb

@@ -0,0 +1,11 @@
+ENV['RACK_ENV'] = 'test'
+
+require 'sinatra/test_helpers'
+require 'sinatra/cookies'
+
+require 'sinatra/authlane'
+
+RSpec.configure do |c|
+  c.include Sinatra::TestHelpers
+  c.include Rack::Test::Methods
+end

data/spec/sinatra_authlane_spec.rb

@@ -0,0 +1,43 @@
+require File.expand_path '../helper.rb', __FILE__
+
+describe Sinatra::AuthLane do
+  def strategy(type, &block)
+    mock_app do
+      register Sinatra::AuthLane
+
+      Sinatra::AuthLane.send "create_#{type}_strategy", &block
+    end
+  end
+
+  it "should allow definition of auth strategy" do
+    strategy(:auth) do
+      'rspec'
+    end
+
+    settings.authlane[:auth_strategy].yield.should == 'rspec'
+  end
+
+  it "should allow definition of role strategy" do
+    strategy(:role) do
+      'rspec'
+    end
+
+    settings.authlane[:role_strategy].yield.should == 'rspec'
+  end
+
+  it "should allow definition of remember strategy" do
+    strategy(:remember) do
+      'rspec'
+    end
+
+    settings.authlane[:remember_strategy].yield.should == 'rspec'
+  end
+
+  it "should allow definition of forget strategy" do
+    strategy(:forget) do
+      'rspec'
+    end
+
+    settings.authlane[:forget_strategy].yield.should == 'rspec'
+  end
+end

metadata

@@ -0,0 +1,149 @@
+--- !ruby/object:Gem::Specification
+name: authlane
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Patrick Lam
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sinatra-contrib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: The AuthLane Sinatra Extension allows easy User authentication with support
+  for different User roles.
+email:
+- zidizei@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".yardopts"
+- Gemfile
+- LICENSE.md
+- README.md
+- Rakefile
+- authlane.gemspec
+- lib/authlane/helper.rb
+- lib/authlane/serializeduser.rb
+- lib/authlane/version.rb
+- lib/sinatra/authlane.rb
+- spec/authlane_helper_spec.rb
+- spec/authlane_serializeduser_spec.rb
+- spec/helper.rb
+- spec/sinatra_authlane_spec.rb
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.1
+signing_key: 
+specification_version: 4
+summary: Easy User authentication and roles for Sinatra.
+test_files:
+- spec/authlane_helper_spec.rb
+- spec/authlane_serializeduser_spec.rb
+- spec/helper.rb
+- spec/sinatra_authlane_spec.rb
+has_rdoc: