kernul 1.0.0

data/History.txt

@@ -0,0 +1,3 @@
+=== 1.0.0 / 2009-01-01
+
+* Initial release

data/Manifest.txt

@@ -0,0 +1,16 @@
+History.txt
+Manifest.txt
+Rakefile
+README.txt
+lib/kernul.rb
+lib/kernul/app.rb
+lib/kernul/base.rb
+lib/kernul/request.rb
+lib/kernul/response.rb
+lib/kernul/unracker.rb
+spec/app_spec.rb
+spec/base_spec.rb
+spec/request_spec.rb
+spec/response_spec.rb
+spec/spec_helper.rb
+spec/unracker_spec.rb

data/README.txt

@@ -0,0 +1,41 @@
+= Kernul, A generic web platform for Ruby.
+
+Kernul is a semi-centralized, highly extensible, and easy to manage generic web platform written in Ruby. Better documentation will come in version 1.1.0.
+
+== Installation
+
+=== Archive Installation
+
+	rake install
+
+=== Gem Installation
+
+Make sure that you have installed jchris-couchrest from github before installing Kernul.
+
+	gem install kernul
+
+== Usage
+	
+	require 'rubygems'
+	require 'kernul'
+	require 'mongrel' # This can be any Rack handler
+	
+	url = 'kernul.com'
+	db = 'localhost:5984/kernul'
+	host = '0.0.0.0'
+	port = 80
+	
+	Kernul::Base.new(:url => url, :db => db, :host => host, :port => port, :handler => Rack::Handler::Mongrel).start
+
+This will start up a Rack server.  If you would only like to create the Rack class because your host requires a Rackup file, simply
+remove the <tt>start</tt> call at the end of the last line.  You can also remove the <tt>:host</tt>, <tt>:port</tt>, and <tt>:handler</tt>
+options.  See Kernul::Base for more details.
+
+
+== Meta
+
+Written by Alex Kern
+
+Copyright (c) 2008-2009 Alex Kern
+
+Released under the MIT License

data/Rakefile

@@ -0,0 +1,23 @@
+require 'rubygems'
+require 'rake'
+require 'rake/rdoctask'
+require 'hoe'
+require './lib/kernul.rb'
+
+Hoe.new('kernul', Kernul::VERSION) do |p|
+  p.name = 'kernul'
+  p.author = 'Alex Kern'
+  p.summary = 'A generic web platform for Ruby.'
+  p.description = 'A semi-centralized, highly extensible, and easy to manage generic web platform written in Ruby.'
+  p.email = 'capnkernul@gmail.com'
+  p.url = 'http://kernul.com/'
+  p.remote_rdoc_dir = ''
+  p.rubyforge_name = 'kernul'
+  p.extra_deps = [['activesupport', '>= 2.0.0'],
+                  ['rack', '>= 0.4.0'],
+                  ['jchris-couchrest', '>= 0.9.0']]
+  
+end
+
+desc "Release and publish documentation"
+task :repubdoc => [:release, :publish_docs]

data/lib/kernul.rb

@@ -0,0 +1,38 @@
+#--
+# Copyright (c) 2008 Alexander Kern
+
+# 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 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.
+#--
+
+$:.unshift File.join(File.dirname(__FILE__),'..','lib')
+
+# The gems
+require 'rubygems'
+require 'active_support'
+require 'rack'
+require 'couchrest'
+require 'rest_client'
+
+module Kernul
+  VERSION = '1.0.0'
+end
+
+# The other files
+require 'kernul/app'
+require 'kernul/request'
+require 'kernul/response'
+require 'kernul/unracker'
+require 'kernul/base'

data/lib/kernul/app.rb

@@ -0,0 +1,16 @@
+class App < CouchRest::Model
+	key_accessor :name, :symbol, :key, :url
+	view_by :symbol
+	
+	# Shortcut to finding an application by its symbol
+	def self.find_by_symbol(symbol)
+		by_symbol(:key => symbol)[0]
+	end
+	
+	# Authenticates an application using its symbol and key
+	def self.authenticate(symbol, key)
+    app = self.find_by_symbol(symbol)
+    return app if app and app.key == key
+    return false
+  end
+end

data/lib/kernul/base.rb

@@ -0,0 +1,91 @@
+module Kernul
+  # Handles all requests in and out of kernul.
+  class Base
+    class << self; attr_accessor :url, :handler, :options, :db; end
+
+    # Creates a new kernul.  It requires some configuration options:
+    # - <tt>:db</tt> - URL of the CouchDB database.
+    # - <tt>:url</tt> - URL that this kernul will be accessed on.
+    #
+    # And one optional one:
+    # - <tt>:handler</tt> - Constant to Rack handler. Needed if using <tt>#start</tt>.
+    # - <tt>:host</tt> - Host to listen on. Needed if using <tt>#start</tt>.
+    # - <tt>:port</tt> - Port to listen on. Needed if using <tt>#start</tt>.
+    # - <tt>:options</tt> - Extra options passed to the handler.
+    def initialize(args)
+      self.class.url = args[:url]
+      self.class.handler = args[:handler]
+      
+      options = { :Host => args[:host], :Port => args[:port] }
+      options.merge!(args[:options]) if args[:options]
+      self.class.options = options
+      
+      self.class.start_db(args[:db])
+    end
+
+    # Starts up the kernul's Rack server.  Not needed on some hosts which require rackup files.
+    def start
+      self.class.handler.run Rack::CommonLogger.new(self), self.class.options
+    end
+
+    # Starts the CouchDB database with CouchRest. Creates the database
+    # if it isn't already created.
+    def self.start_db(url)
+      CouchRest::Model.default_database = CouchRest.database!(url)
+    end
+
+    # Called by Rack whenever there's a request to the kernul.
+    def call(env)
+      begin
+        request = Unracker.unrack_request(env)
+        
+        request.request_app = App.authenticate(request.user, request.password)
+        return Response.invalid_key unless request.request_app
+        
+        request.target_app = App.find_by_symbol(self.class.subdomains(request.url)[-1])
+        return Response.invalid_target unless request.target_app
+        
+        return self.class.dispatch(request)
+      rescue Exception => e
+        return Response.default(e)
+      end
+    end
+
+    # Returns all subdomains of the url provided.
+    def self.subdomains(url, tld_length = 1)
+      parts = URI.parse(url).host.split('.')
+      parts[0..-(tld_length+2)]
+    end
+
+    # Prepares and sends the HTTP request to the target application.
+    def self.dispatch(request)
+      method = request.method
+      url = request.target_app.url << URI.parse(request.url).request_uri
+      headers = dispatch_headers(request)
+      payload = request.payload
+      
+      dispatch = RestClient::Request::NoExceptions.new(:method => method, :url => url, :headers => headers, :payload => payload)
+      retrieve = dispatch.execute
+      retrieve[1] = filter_headers(retrieve[1])
+      retrieve
+    end
+
+    # Prepares the dispatch's headers.
+    def self.dispatch_headers(request)
+      headers = {}
+      request.headers.each { |key, value| headers[key.to_s.gsub(/_/, " ").titleize.gsub(/ /, "-")] = value }
+      
+      headers['Referer'] = "#{request.request_app.symbol}.#{self.url}"
+      headers['Pragma'] = [request.target_app.key, headers['Pragma']].join(' ')
+      headers.delete_if { |key, value| ['Host', 'Version', 'Authorization'].include? key }
+      headers
+    end
+
+    # Filters the returned headers from the dispatch and chooses
+    # which ones will be sent back to the request app.
+    def self.filter_headers(response_headers)
+      response_headers.delete_if { |key, value| ['content-encoding', 'content-length', 'transfer-encoding'].include? key }
+      response_headers
+    end
+  end
+end

data/lib/kernul/request.rb

@@ -0,0 +1,15 @@
+# Extension of RestClient::Request to allow the HTTP code, headers, and body to be
+# directly accessed without the use of exceptions.
+class RestClient::Request
+  attr_accessor :request_app, :target_app # Add the ability to store these apps in a request
+  
+  class NoExceptions < RestClient::Request
+    # Returns the results of the request in the form of a Rack array.
+    def process_result(res)
+      result_headers = res.header.to_hash
+      result_headers.each { |key, value| result_headers[key] = value[0]}
+
+      [res.code, result_headers, decode(res['content-encoding'], res.body)]
+    end
+  end
+end

data/lib/kernul/response.rb

@@ -0,0 +1,30 @@
+# Convenience class to store the possible responses used
+# in a kernul.  They return Rack arrays.
+module Kernul
+  module Response
+    class << self
+      
+      # The Rack array for an invalid symbol and/or key
+      def invalid_key
+        [ 401, {
+          'Content-Type' => 'text/plain',
+          'WWW-Authenticate' => "Basic realm=\"#{Kernul::Base.url}\""
+        }, 'Invalid key' ]
+      end
+
+      # The Rack array if the target doesn't exist or no target is provided
+      def invalid_target
+        [ 400, {
+          'Content-Type' => 'text/plain'
+        }, 'Invalid target' ]
+      end
+      
+      # The Rack array if there was an uncaught error or something horrible occured
+      def default(error='')
+        [ 500, {
+          'Content-Type' => 'text/plain'
+        }, error.to_s ]
+      end
+    end
+  end
+end

data/lib/kernul/unracker.rb

@@ -0,0 +1,50 @@
+# Takes rack environments and makes them into a RestClient requests.
+module Kernul
+  module Unracker
+    # Removes all the important data from the Rack request and returns
+    # a RestClient::Request with that data for easy access.
+    def self.unrack_request(env)
+      url = generate_url(env)
+      
+      if ['GET', 'POST', 'PUT', 'DELETE'].include?(env['REQUEST_METHOD'])
+        method = env['REQUEST_METHOD']
+      else
+        method = 'GET'
+      end
+      
+      headers = unrack_headers(env)
+      payload = env['rack.input']
+      
+      if env['HTTP_AUTHORIZATION']
+        auth = env['HTTP_AUTHORIZATION'].split(" ")[1].unpack("m*").first.split(/:/, 2)
+      else
+        auth = ["",""]
+      end
+
+      user = auth.first
+      password = auth.last
+
+      RestClient::Request.new(:method => method, :url => url, :headers => headers, :user => user, :password => password, :payload => payload)
+    end
+
+    # Recreates the request URL from the Rack environment data.
+    def self.generate_url(env)
+      url = env['rack.url_scheme'] + "://"
+      url << env['SERVER_NAME']
+      url << ":" + env["SERVER_PORT"]
+      url << env['SCRIPT_NAME']
+      url << env['PATH_INFO'] unless env['PATH_INFO'].nil?
+      url << "?" << env['QUERY_STRING'] unless env['QUERY_STRING'].empty?
+      url
+    end
+
+    # Removes all HTTP headers from the Rack environment data and returns
+    # them as a hash.
+    def self.unrack_headers(env)
+      hash = {}
+      http_headers = env.select { |key, value| key[0..4] == "HTTP_" }
+      http_headers.each { |t| hash[t[0].dup[5..-1]] = t[1] }
+      hash
+    end
+  end
+end

data/spec/app_spec.rb

@@ -0,0 +1,26 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe App do
+  it "should be able to find things by symbol" do
+    app = App.new(:symbol => 'test')
+    App.should_receive(:by_symbol).and_return([app])
+    App.find_by_symbol('test').should == app
+  end
+  
+  it "should return nil if no application with that symbol exists" do
+    App.should_receive(:by_symbol).and_return([])
+    App.find_by_symbol('no_such_app').should == nil
+  end
+  
+  it "should be able to authenticate an app" do
+    app = App.new(:symbol => 'symbol', :key => 'key')
+    App.should_receive(:by_symbol).and_return([app])
+    App.authenticate('symbol', 'key').should == app
+  end
+  
+  it "should return false when trying to authenticate an app if the credentials are bad" do
+    app = App.new(:symbol => 'symbol', :key => 'key')
+    App.should_receive(:by_symbol).and_return([app])
+    App.authenticate('wrong', 'wrong').should == false
+  end
+end

data/spec/base_spec.rb

@@ -0,0 +1,150 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe Kernul::Base do
+	it "should be able to create a database" do
+		Kernul::Base.start_db('localhost:5984').should be_an_instance_of(CouchRest::Database)
+	end
+	
+	it "should be able to parse subdomains" do
+	  Kernul::Base.subdomains('http://sub1.lol.com').should == ['sub1']
+	  Kernul::Base.subdomains('http://sub2.sub1.lol.com').should == ['sub2', 'sub1']
+  end
+  
+  it "should change the request headers" do
+    dummy = mock('dummy');
+    dummy.stub!(:headers).and_return('TEST' => 'TEST', 'TEST_TEST' => 'TEST', 'PRAGMA' => 'no-cache', 'HOST' => 'test.com', 'VERSION' => '1.3.3.7', 'AUTHORIZATION' => 'topsecret')
+    dummy.stub!(:request_app).and_return(dummy)
+    dummy.stub!(:symbol).and_return('testing')
+    dummy.stub!(:target_app).and_return(dummy)
+    dummy.stub!(:key).and_return('password')
+    Kernul::Base.should_receive(:url).and_return('example.com')
+    
+    result = Kernul::Base.dispatch_headers(dummy)
+    result['Test'].should == 'TEST'
+    result['Test-Test'].should == 'TEST'
+    result['Referer'].should == 'testing.example.com'
+    result['Pragma'].should == 'password no-cache'
+    result['Host'].should be_nil
+    result['Version'].should be_nil
+    result['Authorization'].should be_nil
+  end
+  
+  it "should filter out the encoding headers from a response" do
+    Kernul::Base.filter_headers('test' => 'test').should == {'test' => 'test'}
+    Kernul::Base.filter_headers('test' => 'test', 'content-encoding' => 'gzip').should == {'test' => 'test'}
+    Kernul::Base.filter_headers('test' => 'test', 'content-length' => '1').should == {'test' => 'test'}
+    Kernul::Base.filter_headers('test' => 'test', 'transfer-encoding' => '1').should == {'test' => 'test'}
+  end
+  
+  it "should be able to dispatch a request" do
+    request = mock('request')
+    target_app = mock('target_app')
+    request.stub!(:method).and_return('GET')
+    request.stub!(:target_app).and_return(target_app)
+    request.stub!(:url).and_return('http://google.com/')
+    request.stub!(:payload).and_return('')
+    target_app.stub!(:url).and_return('http://google.com/')
+    Kernul::Base.should_receive(:dispatch_headers).and_return({})
+    
+    # This will contact google which will always show a 301 Found redirect to their www subdomain.
+    result = Kernul::Base.dispatch(request)
+    result.should be_an_instance_of(Array)
+    result[0].should == '301'
+  end
+  
+  it "should be able to be created without being started" do
+    Kernul::Base.should_receive(:start_db).and_return(true)
+    kernul = Kernul::Base.new(:url => 'kernul.com', :db => 'test')
+  end
+  
+  it "should merge the handler options when created" do
+    kernul = Kernul::Base.new(:url => 'kernul.com', :db => 'test', :host => '0.0.0.0', :port => 80, :options => {:test => 'test'})
+    Kernul::Base.options.should == { :Host => '0.0.0.0', :Port => 80, :test => 'test' }
+  end
+  
+  it "should be able to be started as a Rack server" do
+    handler = mock('handler')
+    handler.should_receive(:run).and_return(true)
+    kernul = Kernul::Base.new(:url => 'kernul.com', :db => 'test', :host => '0.0.0.0', :port => 80, :handler => handler)
+    kernul.start
+  end
+end
+
+describe Kernul::Base, "#call" do
+  it "should unrack the environment" do
+    env = mock('env')
+    Kernul::Unracker.should_receive(:unrack_request).and_return(nil)
+    kernul = Kernul::Base.new(:url => 'kernul.com', :db => 'test')
+    kernul.call(env)
+  end
+  
+  it "should show an invalid key error if the username and password are wrong" do
+    env = mock('env')
+    request = mock('request')
+    request.should_receive(:user).and_return('user')
+    request.should_receive(:password).and_return('password')
+    request.should_receive(:request_app).and_return(false)
+    request.should_receive(:request_app=).and_return(false)
+    App.should_receive(:authenticate).and_return(false)
+    Kernul::Unracker.stub!(:unrack_request).and_return(request)
+    Kernul::Response.should_receive(:invalid_key).and_return([])
+    kernul = Kernul::Base.new(:url => 'kernul.com', :db => 'test')
+    kernul.call(env).should == []
+  end
+  
+  it "should show an invalid target error if an invalid target app is supplied" do
+    env = mock('env')
+    request = mock('request')
+    request_app = mock('request_app')
+    request.stub!(:user).and_return('user')
+    request.stub!(:password).and_return('password')
+    request.stub!(:request_app).and_return(request_app)
+    request.stub!(:request_app=).and_return(request_app)
+    request.should_receive(:url).and_return('test.example.com')
+    request.should_receive(:target_app).and_return(false)
+    request.should_receive(:target_app=).and_return(false)
+    Kernul::Base.should_receive(:subdomains).and_return([])
+    App.stub!(:authenticate).and_return(request_app)
+    App.should_receive(:find_by_symbol).and_return(false)
+    Kernul::Unracker.stub!(:unrack_request).and_return(request)
+    Kernul::Response.should_receive(:invalid_target).and_return([])
+    kernul = Kernul::Base.new(:url => 'kernul.com', :db => 'test')
+    kernul.call(env).should == []
+  end
+  
+  it "should dispatch the request if it is valid" do
+    env = mock('env')
+    request = mock('request')
+    request_app = mock('request_app')
+    target_app = mock('target_app')
+    request.stub!(:user).and_return('user')
+    request.stub!(:password).and_return('password')
+    request.stub!(:request_app).and_return(request_app)
+    request.stub!(:request_app=).and_return(request_app)
+    request.stub!(:url).and_return('test.example.com')
+    request.stub!(:target_app).and_return(target_app)
+    request.stub!(:target_app=).and_return(target_app)
+    Kernul::Base.stub!(:subdomains).and_return([])
+    App.stub!(:authenticate).and_return(request_app)
+    App.stub!(:find_by_symbol).and_return(target_app)
+    Kernul::Unracker.stub!(:unrack_request).and_return(request)
+    Kernul::Base.should_receive(:dispatch).and_return([])
+    kernul = Kernul::Base.new(:url => 'kernul.com', :db => 'test')
+    kernul.call(env).should == []
+  end
+  
+  it "should report database communication errors" do
+    env = mock('env')
+    request = mock('request')
+    request.stub!(:user).and_return('user')
+    request.stub!(:password).and_return('password')
+    request.stub!(:request_app).and_return(false)
+    request.stub!(:request_app=).and_return(false)
+    Kernul::Unracker.stub!(:unrack_request).and_return(request)
+    Kernul::Response.should_receive(:default).and_return([])
+    
+    # This makes the database fail to connect, causing an Exception to be raised.
+    kernul = Kernul::Base.new(:url => 'kernul.com', :db => '1crazyinsaneurl.com')
+    kernul.call(env).should == []
+  end
+end

data/spec/request_spec.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe RestClient::Request::NoExceptions do
+  it "should return a rack array of the response" do
+    dummy = mock('dummy');
+    request = RestClient::Request::NoExceptions.new(:method => 'GET', :url => 'nowhere');
+    dummy.stub!(:code).and_return(200)
+    dummy.stub!(:header).and_return(:test => ['test'])
+    dummy.stub!(:body).and_return('testestest')
+    dummy.stub!(:[]).with('content-encoding').and_return('text/plain')
+    request.should_receive(:decode).and_return('testestest')
+    
+    result = request.process_result(dummy)
+    result.should be_an_instance_of(Array)
+    result.length.should == 3
+    result[0].should be_an_instance_of(Fixnum)
+    result[1].should be_an_instance_of(Hash)
+    result[2].should be_an_instance_of(String)
+  end
+end

data/spec/response_spec.rb

@@ -0,0 +1,20 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe Kernul::Response do
+  it "should return a Rack array" do
+    [Kernul::Response.invalid_key, Kernul::Response.invalid_target, Kernul::Response.default].each do |array|
+      array.should be_an_instance_of(Array)
+      array.length.should == 3
+      array[0].should be_an_instance_of(Fixnum)
+      array[1].should be_an_instance_of(Hash)
+      array[2].should be_an_instance_of(String)
+    end
+  end
+  
+  it "should convert exceptions to text in a default response" do
+    Kernul::Response.default[2].should == ''
+    Kernul::Response.default('')[2].should == ''
+    Kernul::Response.default('test')[2].should == 'test'
+    Kernul::Response.default(ArgumentError)[2].should == 'ArgumentError'
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+require 'test/unit'
+require 'spec'
+
+require File.dirname(__FILE__) + '/../lib/kernul'

data/spec/unracker_spec.rb

@@ -0,0 +1,86 @@
+require File.dirname(__FILE__) + '/spec_helper.rb'
+
+describe Kernul::Unracker do
+  it "should be able to recreate a url" do
+    env = Rack::MockRequest.env_for('http://example.com:80/')
+    Kernul::Unracker.generate_url(env).should == 'http://example.com:80/'
+    
+    env = Rack::MockRequest.env_for('http://lol.example.com:80/')
+    Kernul::Unracker.generate_url(env).should == 'http://lol.example.com:80/'
+    
+    env = Rack::MockRequest.env_for('http://example.com:23/')
+    Kernul::Unracker.generate_url(env).should == 'http://example.com:23/'
+    
+    env = Rack::MockRequest.env_for('https://example.com:80/')
+    Kernul::Unracker.generate_url(env).should == 'https://example.com:80/'
+    
+    env = Rack::MockRequest.env_for('http://example.com:80/lol')
+    Kernul::Unracker.generate_url(env).should == 'http://example.com:80/lol'
+    
+    env = Rack::MockRequest.env_for('http://example.com:80/?lol')
+    Kernul::Unracker.generate_url(env).should == 'http://example.com:80/?lol'
+    
+    env = Rack::MockRequest.env_for('http://example.com:80/#lol')
+    Kernul::Unracker.generate_url(env).should == 'http://example.com:80/'
+  end
+  
+  it "should be able to unrack the headers" do
+    env = Rack::MockRequest.env_for('http://example.com:80/')
+    Kernul::Unracker.unrack_headers(env).should == {}
+    
+    env = Rack::MockRequest.env_for('http://example.com:80/', {'lol' => 'lol'})
+    Kernul::Unracker.unrack_headers(env).should == {}
+    
+    env = Rack::MockRequest.env_for('http://example.com:80/', {'HTTP_REFERER' => 'lol'})
+    Kernul::Unracker.unrack_headers(env).should == {'REFERER' => 'lol'}
+  end
+end
+
+describe Kernul::Unracker, "#unrack_request" do
+  it "should return a RestClient::Request" do
+    env = Rack::MockRequest.env_for('http://example.com:80/')
+    Kernul::Unracker.unrack_request(env).should be_an_instance_of(RestClient::Request)
+  end
+  
+  it "should have a method" do
+    env = Rack::MockRequest.env_for('http://example.com:80/')
+    Kernul::Unracker.unrack_request(env).method.should == 'GET'
+    
+    env = Rack::MockRequest.env_for('http://example.com:80/', {:method => 'GET'})
+    Kernul::Unracker.unrack_request(env).method.should == 'GET'
+    
+    env = Rack::MockRequest.env_for('http://example.com:80/', {:method => 'POST'})
+    Kernul::Unracker.unrack_request(env).method.should == 'POST'
+    
+    env = Rack::MockRequest.env_for('http://example.com:80/', {:method => 'PUT'})
+    Kernul::Unracker.unrack_request(env).method.should == 'PUT'
+    
+    env = Rack::MockRequest.env_for('http://example.com:80/', {:method => 'DELETE'})
+    Kernul::Unracker.unrack_request(env).method.should == 'DELETE'
+    
+    env = Rack::MockRequest.env_for('http://example.com:80/', {:method => 'NOTAMETHOD'})
+    Kernul::Unracker.unrack_request(env).method.should == "GET"
+  end
+  
+  it "should be able to have a payload" do
+    env = Rack::MockRequest.env_for('http://example.com:80/')
+    Kernul::Unracker.unrack_request(env).payload.read.should == ''
+    
+    env = Rack::MockRequest.env_for('http://example.com:80/', :input => "lol")
+    Kernul::Unracker.unrack_request(env).payload.read.should == 'lol'
+  end
+  
+  it "should have a username and password" do
+    env = Rack::MockRequest.env_for('http://example.com:80/')
+    Kernul::Unracker.unrack_request(env).user.should == ""
+    Kernul::Unracker.unrack_request(env).password.should == ""
+    
+    env = Rack::MockRequest.env_for('http://example.com:80/', 'HTTP_AUTHORIZATION' => "Basic #{['lol:rofl'].pack("m*")}")
+    Kernul::Unracker.unrack_request(env).user.should == "lol"
+    Kernul::Unracker.unrack_request(env).password.should == "rofl"
+    
+    env = Rack::MockRequest.env_for('http://example.com:80/', 'HTTP_AUTHORIZATION' => 'Basic lol:rofl')
+    Kernul::Unracker.unrack_request(env).user.should_not == "lol"
+    Kernul::Unracker.unrack_request(env).password.should_not == "rofl"
+  end
+end

metadata

@@ -0,0 +1,110 @@
+--- !ruby/object:Gem::Specification 
+name: kernul
+version: !ruby/object:Gem::Version 
+  version: 1.0.0
+platform: ruby
+authors: 
+- Alex Kern
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-01-01 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.4.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: jchris-couchrest
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.9.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.8.2
+    version: 
+description: A semi-centralized, highly extensible, and easy to manage generic web platform written in Ruby.
+email: capnkernul@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- History.txt
+- Manifest.txt
+- README.txt
+files: 
+- History.txt
+- Manifest.txt
+- Rakefile
+- README.txt
+- lib/kernul.rb
+- lib/kernul/app.rb
+- lib/kernul/base.rb
+- lib/kernul/request.rb
+- lib/kernul/response.rb
+- lib/kernul/unracker.rb
+- spec/app_spec.rb
+- spec/base_spec.rb
+- spec/request_spec.rb
+- spec/response_spec.rb
+- spec/spec_helper.rb
+- spec/unracker_spec.rb
+has_rdoc: true
+homepage: http://kernul.com/
+post_install_message: 
+rdoc_options: 
+- --main
+- README.txt
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: kernul
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: A generic web platform for Ruby.
+test_files: []
+