rack-casual 0.0.1 → 0.1.0

data/README.md

@@ -6,16 +6,25 @@ It kicks in whenever a 401 response is returned from the server.
 
 The plugin has only been tested using ActiveRecord and Rails 3.
 
+
 Installation
 ============
 
+### Sinatra
+
+  $ gem install 'rack-casual'
+  
+See examples/sinatra_app.rb for a sample app.
+
+### Rails 3
+
 Add this to your Gemfile:
 
-  gem 'rack-casual'
+    $ gem 'rack-casual'
   
 Run bundle install, and add a configuration file:
 
-  $ rails generate rack_casual
+    $ rails generate rack_casual
   
 This creates a config/initializers/rack-casual.rb file. 
 Make sure base_url points to your CAS server.
@@ -27,9 +36,9 @@ For Rails3, you can add this to your config/application.rb
 
 Finally, to authenticate your users, add a before_filter to your controller:
 
-  class ApplicationController < ActionController::Base
-    before_filter :authenticate!
-  end
+    class ApplicationController < ActionController::Base
+      before_filter :authenticate!
+    end
 
 
 Usage
@@ -62,25 +71,19 @@ If there are no users with that token, the client just receives the 401 error.
 It does not fallback to CAS or create a user automatically (doh).
 
 
-Finding users
+Authorization
 =============
 
-If you want to control how Rack::Casual finds the user, you can set a scope to be used.
-  # config/initializers/rack-casual.rb:
-  config.authentication_scope = :active
+Rack::Casual calls active? on your user model if that method exists to determine whether the user can log in or not.
+So just add this to control whether authenticated users can log in or not.
   
-  # app/models/user.rb
-  class User < ActiveRecord::Base
-    def self.active
-      where(:active => true)
+    # app/models/user.rb
+    class User < ActiveRecord::Base
+      def active?
+        # i'm sure you can figure something out...
+      end
     end
-  end
   
-Then Rack::Casual will only search among users where active is true.
-A side effect of this is that Rack::Casual will try to create a user that already exists.
-However, this should not be a problem as long as your User model validates the uniqueness of the username.
-
-The default scope to use is
 
 Extra attributes
 ================
@@ -89,17 +92,17 @@ When creating users automatically, Rack::Casual can also add extra attributes if
 For this to work your User model must have a cas_extra_attributes= instance method.
 Here's an example:
 
-  class User < ActiveRecord::Base
-    def cas_extra_attributes=(extra_attributes)
-      extra_attributes.each do |name, value|
-        case name.to_sym
-          when :name   then self.name   = value
-          when :email  then self.email  = value
-          when :phone  then self.phone  = value
+    class User < ActiveRecord::Base
+      def cas_extra_attributes=(extra_attributes)
+        extra_attributes.each do |name, value|
+          case name.to_sym
+            when :name   then self.name   = value
+            when :email  then self.email  = value
+            when :phone  then self.phone  = value
+          end
         end
       end
     end
-  end
   
 
 Tracking
@@ -114,8 +117,6 @@ These variables will be updated if they are present in your User model:
 TODO
 ====
 
-1. Testing. How embarrasing. A gem without tests is like a forrest without trees.
-2. Replace ruby-cas with something "lighter", like casual, but casual doesn't seem to support extra attributes...
-   Note to self: http://rubycas-client.rubyforge.org/classes/CASClient/ValidationResponse.src/M000044.html
+More tests dammit.
 
 Copyright (c) 2010 Gudleik Rasch <gudleik@gmail.com>, released under the MIT license

data/examples/sinatra_app.rb

@@ -0,0 +1,67 @@
+# encoding: utf-8
+require 'rubygems'
+require 'sinatra'
+require 'rack-casual'
+
+##
+## This is an example Sinatra app using Rack::Casual for authentication
+##
+## Start with ruby sinatra_app.rb 
+## If you go to http://localhost:4567 you should be redirected to the CAS server.
+## Or if you enter http://localhost:4567?auth_token=secret you're authenticated.
+##
+
+use Rack::Lint
+use Rack::Casual::Authentication
+
+Rack::Casual.setup do |config|
+  config.cas_url     = "http://localhost:8080"
+  config.auth_token  = "auth_token"
+  config.session_key = "user"
+  config.create_user = false
+end
+
+# User class with a few activerecord-ish methods to make Rack::Casual work properly.
+# Didn't want to roll in a full activerecord orchestra for this example purpose.
+class User
+  attr_accessor :last_login_ip, :last_login_at, :login_count
+  
+  # This is used by Rack::Casual to locate the user.
+  def self.where(conditions)
+    if conditions["auth_token"] == "secret"       # find by auth_token
+      [ User.new("foobar") ]
+    elsif conditions["username"] == "foobar"      # find by username
+      [ User.new("foobar") ]
+    else
+      []    # Must return an empty array to satisfy Rack::Casual (it uses .first)
+    end
+  end
+  
+  def id
+    42
+  end
+  
+  def active?
+    false
+  end
+  
+  def save
+    # Just print out some info to see that these 
+    puts "Last login IP: #{@last_login_ip}"
+  end
+  
+  def initialize(username)
+    @username = username
+    @login_count = 0
+  end
+end
+
+set :sessions, true
+
+before do
+  halt 401, 'Forbidden dammit' unless session["user"]
+end
+
+get '/' do
+  %{Hello, your user-id is #{session["user"]}}
+end

data/lib/rack/casual/authentication.rb

@@ -1,7 +1,21 @@
+# encoding: utf-8
 module Rack
   
   module Casual
-    
+
+    # How it works
+    # 
+    # 1. Request enters app
+    # 2. Is params[:ticket] present with a valid CAS ticket
+    # 3.    `- Validate ticket
+    #          If valid find or create user
+    #          User not ok? -- show bad info, don't redirect back to cas
+    #          User ok? -- set user.id in session and continue
+    # 5. Is response a 401?
+    # 6.    `- Authenticate using auth_token if auth_token is present
+    #       `- Or redirect to CAS
+    # 7. Done
+    # 
     class Authentication
       
       def initialize(app)
@@ -10,67 +24,76 @@ module Rack
   
       def call(env)
         @request  = Rack::Request.new(env)
-        @response = @app.call(env)
         @env = env
     
-        process_request_from_cas
-        handle_401
+        unless process_request_from_cas
+          @app.call(env)
+        else
+          handle_401(@app.call(env))
+        end
       end
   
       private
   
+      # This handles requests from CAS
+      # CAS requests must include a ticket in the params.
+      # Only returns true if a CAS ticket was processed but returned no users
       def process_request_from_cas
         if ticket = read_ticket
-          if user = UserFactory.authenticate_with_cas_ticket(ticket, @request)
-            # TODO: remove the params['ticket'] so the app doesn't see this...
-            @request.session[Rack::Casual.session_key_user] = user.id
+          if user = UserFactory.authenticate_with_cas_ticket(ticket, service_url, @request.ip)
+            set_session(user)
           else
-            # [ 403, { "Content-Type" => "text/plain" }, "Sorry, I was unable to authenticate you" ]
+            return false
           end
         end
+        
+        true
       end
 
-      def handle_401
-        return @response unless @response[0] == 401
+      # This handles 401 responses by either authenticating using a token if present in params,
+      # or redirects to CAS login
+      def handle_401(response)
+        return response unless response[0] == 401
     
-        if Rack::Casual.auth_token_key && @request.params[Rack::Casual.auth_token_key]
-          authenticate_with_token
+        if Rack::Casual.auth_token && token = @request.params[Rack::Casual.auth_token]
+          authenticate_with_token(token)
         else
           redirect_to_cas
         end
       end
       
-      def authenticate_with_token
-        user = UserFactory.authenticate_with_token(@request)
-        @request.session[Rack::Casual.session_key_user] = user.id if user
+      # Authenticate user by a token
+      def authenticate_with_token(token)
+        set_session UserFactory.authenticate_with_token(token, @request.ip)
         @app.call(@env)
       end
-  
+
+      # Stores user.id in the session key configured in Rack::Casual.session_key
+      def set_session(user)
+        @request.session[Rack::Casual.session_key] = user.id if user
+      end
+      
+      # Redirects to CAS
       def redirect_to_cas
-        url = Rack::Casual.cas_client.add_service_to_login_url(service_url)
         [ 302, 
           { 
-            "Location"      => url,
+            "Location"      => Client.login_url(service_url),
             "Content-Type"  => "text/plain" 
           }, 
           "Redirecting to CAS for authentication" 
         ]
       end
-  
+    
+      # Return the service url for this application (minus the ticket parameter)
       def service_url
         @request.url.sub(/[\?&]#{Rack::Casual.ticket_param}=[^\?&]+/, '')
       end
   
-      # Read ticket from params and create a CASClient ticket
+      # Read ticket from params and return a string if a CAS ticket is present.
+      # Otherwise returns nil
       def read_ticket
         ticket = @request.params[Rack::Casual.ticket_param]
-        return nil unless ticket
-          
-        if ticket =~ /^PT-/
-          ::CASClient::ProxyTicket.new(ticket, service_url, @request.params[:renew])
-        else
-          ::CASClient::ServiceTicket.new(ticket, service_url, @request.params[:renew])
-        end
+        ticket =~ /^(S|P)T-/ ? ticket : nil
       end
 
     end

data/lib/rack/casual/client.rb

@@ -0,0 +1,130 @@
+# encoding: utf-8
+
+require 'nokogiri'
+require 'open-uri'
+require 'net/http'
+require 'net/https'
+
+# This is a über simple CAS client responsible for validating a ticket.
+class Rack::Casual::Client
+  attr_accessor :username, :extra_attributes
+
+  # Returns login url as string
+  def self.login_url(service_url)
+    new(service_url).login_url.to_s
+  end
+  
+  # Creates a new object
+  def initialize(service_url, ticket=nil)
+    raise(ArgumentError, "Base URL must be configured") if Rack::Casual.cas_url.nil?
+
+    @service_url  = service_url    
+    @ticket       = ticket
+    @result       = nil
+  end
+  
+  # Return the URL to the CAS login page
+  def login_url
+    cas_url(:login)
+  end
+  
+  # URL to the CAS ticket validation service
+  def validation_url
+    cas_url(:validate)
+  end
+
+  # Validate the ticket we got from CAS
+  #
+  # On ticket validation success:
+  # <cas:serviceResponse xmlns:cas='http://www.yale.edu/tp/cas'>
+  #     <cas:authenticationSuccess>
+  #         <cas:user>username</cas:user>
+  #             <cas:proxyGrantingTicket>PGTIOU-84678-8a9d...
+  #         </cas:proxyGrantingTicket>
+  #     </cas:authenticationSuccess>
+  # </cas:serviceResponse>
+  # 
+  # On ticket validation failure:
+  # <cas:serviceResponse xmlns:cas='http://www.yale.edu/tp/cas'>
+  #     <cas:authenticationFailure code="INVALID_TICKET">
+  #         Ticket ST-1856339-aA5Yuvrxzpv8Tau1cYQ7 not recognized
+  #     </cas:authenticationFailure>
+  # </cas:serviceResponse>
+  # 
+  #
+  def validate_ticket
+    url = validation_url
+    http = Net::HTTP.new(url.host, url.port)
+    http.use_ssl = (url.scheme == "https") 
+    
+    result = Nokogiri.parse(http.get(url.request_uri).body)
+
+    # set username and extra attributes
+    find_username(result)
+    find_attributes(result) if @username
+
+    !@username.nil?
+  end
+  
+  def find_username(xml)
+    @username = xml.search("//cas:authenticationSuccess //cas:user").first.text rescue nil
+  end
+  
+  def find_attributes(xml)
+    @extra_attributes = {}
+    xml.search("//cas:authenticationSuccess/*").each do |el|
+      # puts " * Attribute #{el.name} = #{el.content}"
+      @extra_attributes[el.name] = el.content
+    end
+  end
+
+  # For testing purposes only
+  #
+  # Fetch login ticket from the CAS login page
+  # def acquire_login_ticket(service_url=nil)
+  #   Nokogiri.parse(open(login_url(service_url)).read).search('input[@name=lt]').first.attr('value') rescue nil
+  # end
+  # 
+  # def authenticate(username, password, ticket, service_url=nil)
+  #   ticket = acquire_login_ticket(service_url)
+  #   url    = login_url(service_url)
+  # 
+  #   query  = url.query ? url.query : ""
+  #   query  += "&" + build_query(:username => username, :password => password, :lt => ticket, :service => service_url)
+  #   
+  #   req    = Net::HTTP.new(url.host, url.port)
+  #   res    = req.post url.path, query
+  #   
+  #   res.is_a?(Net::HTTPSuccess)
+  # end
+
+  #
+  # Returns a CAS url
+  # if action is :login or :validate, then the appropriate login and service-validation actions are used.
+  # Otherwise the argument is used as the first action.
+  #
+  # Options is a hash that is appended to the url.
+  #
+  # Return value is a URI object.
+  #
+  # Examples:
+  #
+  #   cas_url :login                          # => http://localhost/login
+  #   cas_url :validate, :ticket => "T123"    # => http://localhost/serviceValidate?ticket=T123
+  #
+  def cas_url(action=nil, options = nil)
+    url = Rack::Casual.cas_url.sub(/\/+$/, '')
+    
+    url << case action
+    when :login    then "/login"
+    when :validate then "/serviceValidate"
+    else
+      action.to_s
+    end
+    
+    url += "?service=#{@service_url}"
+    url += "&ticket=#{@ticket}" if @ticket
+    URI.parse(url)
+  end
+      
+end

data/lib/rack/casual/controller.rb

@@ -1,3 +1,4 @@
+# encoding: utf-8
 module Rack
   
   module Casual

data/lib/rack/casual/user_factory.rb

@@ -4,45 +4,60 @@ module Rack
     
     class UserFactory
 
-      def self.authenticate_with_cas_ticket(ticket, request)
-        user = nil
-        Rack::Casual.cas_client.validate_service_ticket(ticket) unless ticket.has_been_validated?
-
-        if ticket.is_valid?
-
-          # find user
-          user = find(ticket.response.user)
-
+      # 
+      # Authenticate user by CAS.
+      #
+      # If ticket is valid it will search for user with the given username.
+      # If no user is found it will be automatically created if +Rack::Casual.create_user+ is set.
+      #
+      # Returns the user or nil if user not found
+      #      
+      def self.authenticate_with_cas_ticket(ticket, service_url, ip)
+        user   = nil
+        client = Client.new(service_url, ticket)
+        
+        if client.validate_ticket
+          # find or create the user
+          user = find(client.username)
           if user.nil? && Rack::Casual.create_user
-            user = make(ticket.response.user)
+            user = make(client.username)
           end
 
-          return nil unless user
+          return nil if user.nil? || user_not_active(user)
 
+          # Set extra attributes if supported by user
           if user.respond_to?(:cas_extra_attributes=)
-            user.cas_extra_attributes = ticket.response.extra_attributes 
+            user.cas_extra_attributes = client.extra_attributes 
           end
 
-          update_tracking(user, request)
+          update_tracking(user, ip)
         end
 
-        user    
+        user
       end
 
-      protected
-      
-      def self.authenticate_with_token(request)
-        user = authentication_scope.where(Rack::Casual.auth_token_key => request.params[Rack::Casual.auth_token_key]).first
-        update_tracking(user, request) if user
+      #
+      # Find user by authentication token.
+      # If user exists and tracking is enabled, tracking info is updated.
+      # Returns user or nil if user not found.
+      #
+      def self.authenticate_with_token(token, ip)
+        user = resource.where(Rack::Casual.auth_token => token).first
+        return nil if user_not_active(user)
+        update_tracking(user, ip) if user
         user
       end
+      
+      def self.user_not_active(user)
+        user.respond_to?(:active?) && user.send(:active?) == false
+      end
 
       # Update tracking info (last logged in at / ip) if tracking_enabled is set.
       # Saves the user regardless of whether tracking was updated or not.
-      def self.update_tracking(user, request)
+      def self.update_tracking(user, ip)
         if Rack::Casual.tracking_enabled
           user.last_login_at = Time.now   if user.respond_to?(:last_login_at)
-          user.last_login_ip = request.ip if user.respond_to?(:last_login_ip)
+          user.last_login_ip = ip         if user.respond_to?(:last_login_ip)
           user.login_count += 1           if user.respond_to?(:login_count)
         end
         user.save
@@ -50,7 +65,7 @@ module Rack
 
       # Find user by username
       def self.find(username)
-        authentication_scope.where(Rack::Casual.username => username).first
+        resource.where(Rack::Casual.username => username).first
       end
 
       # Initializes a new user
@@ -60,19 +75,9 @@ module Rack
 
       # Returns the user class
       def self.resource
-        Rack::Casual.user_class.constantize
+        # Rack::Casual.user_class.constantize
+        Kernel.const_get(Rack::Casual.user_class)
       end
-      
-      # Returns the scope used to find users
-      def self.authentication_scope
-        if Rack::Casual.authentication_scope
-          puts "Authentication scope is kinda broken and should be avoided"
-          resource.send(Rack::Casual.authentication_scope)
-        else
-          resource.scoped
-        end
-      end
-      
     end
     
   end  

data/lib/rack/casual.rb

@@ -6,75 +6,107 @@ module Rack
   module Casual
 
     autoload :Authentication, 'rack/casual/authentication'
+    autoload :Client,         'rack/casual/client'
     autoload :UserFactory,    'rack/casual/user_factory'
     autoload :Controller,     'rack/casual/controller'
+    
+    # Default options
+    defaults = {
+      :cas_url          => nil,                 # CAS URL
+      :session_key      => "user",              # Name of session key to store the user-id in
+      :ticket_param     => "ticket",            # Name of parameter for the CAS ticket
+      :create_user      => true,                # Automatic user creation
+      :user_class       => "User",              # Name of user model
+      :username         => "username",          # Name of username attribute in User model
+      :auth_token       => "auth_token",        # Name of authentication token attribute in User model
+      :tracking_enabled => true,                # Enable tracking on user
+    }
+
+    # Create attribute accessors for each key/value pair in options.
+    defaults.each do |key, value|
+      # value = value.is_a?(String) ? "'#{value}'" : %Q{"#{value}"}
+      class_eval <<-EOS
+        @@#{key} = nil unless defined? @@#{key}
+        
+        def self.#{key}
+          @@#{key}
+        end
+
+        def self.#{key}=(value)
+          @@#{key} = value
+        end
+      EOS
+      
+      # set the default value
+      self.send("#{key}=", value)
+    end
 
-    # Base URI to your CAS server
-    mattr_accessor :base_url
-    @@base_url = 'http://192.168.0.15:8088'
-
-    # URI to CAS login
-    # Default is base_url/login
-    mattr_accessor :login_url
-    @@login_url = nil
-
-    # URI to CAS logout
-    # Default is base_url/logout
-    mattr_accessor :logout_url
-    @@logout_url = nil
-
-    # URI to service validation
-    # Default is base_url/serviceValidate
-    mattr_accessor :validate_url
-    @@validate_url = nil
-
-    # Name of authentication token to use in params
-    # Set to nil to disable token authentication
-    mattr_accessor :auth_token_key
-    @@auth_token_key = "auth_token"
-
-    # Name of the ticket parameter used by CAS
-    mattr_accessor :ticket_param
-    @@ticket_param = "ticket"
-
-    # Name of key to store user id
-    # Default is 'user' => session[:user]
-    mattr_accessor :session_key_user
-    @@session_key_user = "user"
-
-    # Use this scope when finding users
-    mattr_accessor :authentication_scope
-    @@authentication_scope = nil
-
-    # Set to true to auto-create users
-    mattr_accessor :create_user
-    @@create_user = true
-
-    # Name of the User class
-    mattr_accessor :user_class
-    @@user_class = "User"
-
-    # Username attribute on user
-    mattr_accessor :username
-    @@username = "username"
-
-    # Update user with last_login_at and last_login_ip info
-    mattr_accessor :tracking_enabled
-    @@tracking_enabled = true
-
-    # Default way to setup Devise. Run rails generate devise_install to create
+    # # URI to CAS login
+    # # Default is base_url/login
+    # def self.login_url; @@login_url; end
+    # def self.login_url=(login_url)
+    # 
+    # mattr_accessor :login_url
+    # @@login_url = nil
+    # 
+    # # URI to CAS logout
+    # # Default is base_url/logout
+    # mattr_accessor :logout_url
+    # @@logout_url = nil
+    # 
+    # # URI to service validation
+    # # Default is base_url/serviceValidate
+    # mattr_accessor :validate_url
+    # @@validate_url = nil
+    # 
+    # # Name of authentication token to use in params
+    # # Set to nil to disable token authentication
+    # mattr_accessor :auth_token_key
+    # @@auth_token_key = "auth_token"
+    # 
+    # # Name of the ticket parameter used by CAS
+    # mattr_accessor :ticket_param
+    # @@ticket_param = "ticket"
+    # 
+    # # Name of key to store user id
+    # # Default is 'user' => session[:user]
+    # mattr_accessor :session_key_user
+    # @@session_key_user = "user"
+    # 
+    # # Use this scope when finding users
+    # mattr_accessor :authentication_scope
+    # @@authentication_scope = nil
+    # 
+    # # Set to true to auto-create users
+    # mattr_accessor :create_user
+    # @@create_user = true
+    # 
+    # # Name of the User class
+    # mattr_accessor :user_class
+    # @@user_class = "User"
+    # 
+    # # Username attribute on user
+    # mattr_accessor :username
+    # @@username = "username"
+    # 
+    # # Update user with last_login_at and last_login_ip info
+    # mattr_accessor :tracking_enabled
+    # @@tracking_enabled = true
+
+    # Setup Rack::Casual. Run rails generate rack_casual to create
     # a fresh initializer with all configuration values.
     def self.setup
       yield self
     end
 
     def self.cas_client
-      @@cas_client ||= ::CASClient::Client.new(
-          :cas_base_url => @@base_url,
-          :login_url    => @@login_url,
-          :logout_url   => @@logout_url,
-          :validate_url => @@validate_url
-        )
+      @@cas_client ||= Client.new
+      # @@cas_client ||= ::CASClient::Client.new(
+      #     :cas_base_url => @@base_url,
+      #     :login_url    => @@login_url,
+      #     :logout_url   => @@logout_url,
+      #     :validate_url => @@validate_url
+      #   )
     end
 
   end

data/lib/rack-casual.rb

@@ -1,2 +1 @@
-require 'rubycas-client'
 require 'rack/casual'

metadata

@@ -1,12 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: rack-casual
 version: !ruby/object:Gem::Version 
+  hash: 27
   prerelease: false
   segments: 
   - 0
-  - 0
   - 1
-  version: 0.0.1
+  - 0
+  version: 0.1.0
 platform: ruby
 authors: 
 - Gudleik Rasch
@@ -14,39 +15,59 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-09-02 00:00:00 +02:00
+date: 2010-09-03 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
-  name: rubycas-client
+  name: nokogiri
   prerelease: false
   requirement: &id001 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 1
         segments: 
-        - 2
-        - 2
         - 1
-        version: 2.2.1
+        - 4
+        - 3
+        version: 1.4.3
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
-  name: activerecord
+  name: rspec
   prerelease: false
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
     - - ~>
       - !ruby/object:Gem::Version 
+        hash: 62196427
         segments: 
-        - 3
+        - 2
         - 0
-        version: "3.0"
-  type: :runtime
+        - 0
+        - beta
+        - 20
+        version: 2.0.0.beta.20
+  type: :development
   version_requirements: *id002
-description: Rack module for authentication using CAS and/or tokens
+- !ruby/object:Gem::Dependency 
+  name: webmock
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 9
+        segments: 
+        - 1
+        - 3
+        version: "1.3"
+  type: :development
+  version_requirements: *id003
+description: Rack middleware for authentication using CAS and/or tokens
 email: 
 - gudleik@gmail.com
 executables: []
@@ -60,12 +81,14 @@ files:
 - lib/generators/templates/initializer.rb
 - lib/generators/USAGE
 - lib/rack/casual/authentication.rb
+- lib/rack/casual/client.rb
 - lib/rack/casual/controller.rb
 - lib/rack/casual/user_factory.rb
 - lib/rack/casual.rb
 - lib/rack-casual.rb
 - LICENSE
 - README.md
+- examples/sinatra_app.rb
 has_rdoc: true
 homepage: http://github.com/gudleik/rack-casual
 licenses: []
@@ -80,6 +103,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 3
       segments: 
       - 0
       version: "0"
@@ -88,6 +112,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      hash: 21
       segments: 
       - 1
       - 3