useless 0.0.6

data/.gitignore

@@ -0,0 +1,3 @@
+Gemfile.lock
+log/*.log
+pkg/*

data/DOC.html

@@ -0,0 +1,28 @@
+<h1 class="platform-title"><span class="the-name-of-the-website">useless.io</span> the useless platform</h1>
+
+<p class="platform-description">a collection of APIs that are more or less useless.</p>
+
+<h2>Platform Guidelines</h2>
+
+<h3>Authentication</h3>
+
+<p>Some endpoints require authentication. In order to do so, the client must
+specify an <em>access token</em>. This can be done by using either the
+<code>Authorization</code> request header field or the
+<code>access_token</code> query string parameter. For example:</p>
+
+<pre>
+GET /photos/1 HTTP/1.1
+Host: street-art.useless.io
+Authorization: 7Fjfp0ZBr1KtDRbnfVdmIw
+</pre>
+
+<p>If an endpoint requires authentication and an access token is not specified
+using one of these methods, a <code>401 Unauthorized</code> response will be returned. If
+an invalid access token is ever specified, regardless of whether the endpoint
+requires authentication, a <code>401 Unauthorized</code> response will also be returned.</p>
+
+<h3>Dates</h3>
+
+<p>All dates are UTC and will conform to the ISO 8601 format. If a request expects
+date or time data, it should formatted in the same way. For example: <code>2011-11-13T21:23:47+00:00</code></p>

data/Gemfile

@@ -0,0 +1,2 @@
+source "http://rubygems.org"
+gemspec

data/README.md

@@ -0,0 +1,23 @@
+useless
+=======
+
+A lightweight Rack stack that forms the platform for useless.io.
+
+useless's primary responsibility is to dispatch requests to the APIs
+based upon subdomain. It also provides a minimal common interface that
+includes:
+
+1. _authentication_ - if a request can be authenticated by a supported
+strategy, the middleware will set the 'useless.user' environment key to the
+associated user record.
+
+2. _persistence_ - the platform provides access to a Mongo driver instance
+via the `Useless::Mongo` class. An instance is provided in the env via
+'useless.mongo'.
+
+3. _file storage_ - all files should be stored using the `Useless::FS` instance.
+provided in the env by 'useless.fs'. Any file stored using `Useless::FS` is
+assigned an ID and is served from the '/files/[ID]' endpoint.
+
+4. _logging_ - the platform sets up a logger appropriate for the environment.
+It can be accessed using 'useless.logger' environment key.

data/Rakefile

@@ -0,0 +1,2 @@
+#!/usr/bin/env rake
+require 'bundler/gem_tasks'

data/assets/application.css

@@ -0,0 +1,134 @@
+body {
+  margin: 0;
+  font-family: "Helvetica Neue", Helvetica, Arial, sans-serif;
+  font-size: 16px;
+  color: #333;
+  line-height: 21px;
+  font-weight: 200;
+  background-color: #EEE;
+}
+
+#container {
+  margin: 0 auto;
+  width: 760px;
+  padding: 3em 2em;
+  border-left: 1px solid #DDD;
+  border-right: 1px solid #DDD;
+  background-color: #FFF;
+}
+
+h1, h2, h3, h4, h5, h6 {
+  font-weight: normal;
+}
+
+h1 {
+  margin: 0 0 .25em;
+}
+
+h1.platform-title {
+  color: #999;
+}
+
+h1.platform-title span.the-name-of-the-website {
+  color: #333;
+}
+
+h2 {
+  border-bottom: 1px solid #DDD;
+  padding-bottom: 0.25em;
+}
+
+h3.endpoint, h3.endpoint pre {
+  margin-bottom: 0.25em;
+}
+
+h3 {
+  font-size: 1.25em;
+  margin-top: 4em;
+}
+
+h3:first-of-type {
+  margin-top: inherit;
+}
+
+h4 {
+  font-weight: bold;
+  margin-bottom: 0.25em;
+}
+
+p.api-description, p.platform-description {
+  margin-bottom: 3em;
+}
+
+p.platform-description {
+  margin-top: 0;
+  color: #AAA;
+}
+
+p.endpoint-description {
+  margin-top: 0;
+}
+
+code.base-api-url {
+  color: #777777;
+  display: block;
+}
+
+ul.attributes {
+  overflow: hidden;
+  *zoom: 1;
+  padding: 0;
+  margin: 0;
+  list-style: none;
+  margin-bottom: 2em;
+}
+
+ul.attributes li {
+  float: left;
+  padding: 3px 10px;
+  border: 1px solid #DDD;
+  background-color: #EEE;
+  font-size: 0.8em;
+}
+
+ul.attributes li.called-out {
+  border-color: #AAA;
+  background-color: lightYellow;
+}
+
+table {
+  width: 100%;
+  border: 1px solid #DDD;
+  border-spacing: 0;
+}
+
+table th {
+  font-weight: inherit;
+}
+
+table td, th {
+  border-right: 1px solid #DDD;
+  border-bottom: 1px solid #DDD;
+  padding: 5px;
+}
+
+table th {
+  text-align: left;
+  color: #999;
+}
+
+table td:last-child, table th:last-child {
+  border-right-width: 0;
+}
+
+table tbody tr:last-child td, table tbody tr:last-child th {
+  border-bottom-width: 0;
+}
+
+pre.example {
+  margin-top: 0;
+  padding: 1em;
+  border: 1px solid #DDD;
+  background-color: #EEE;
+  overflow: auto;
+}

data/lib/useless/rack/base/doc.rb

@@ -0,0 +1,12 @@
+module Useless
+  class Rack
+    class Base
+      # Useless::Base::Doc just calls .serve on `useless.doc`
+      module Doc
+        def self.call(env)
+          env['useless.doc'].serve File.expand_path('../../../../DOC.html', __FILE__)
+        end
+      end
+    end
+  end
+end

data/lib/useless/rack/base/files.rb

@@ -0,0 +1,31 @@
+module Useless
+  class Rack
+    class Base
+      # Useless::Base::Files simply retrieves files from Useless::FS and serves
+      # them up.
+      class Files
+        # Provide a helper method for file URLs to keep things consistent.
+        def self.url_for(id)
+          "http://useless.io/files/#{id}"
+        end
+
+        def call(env)
+          # The file ID is everything after the initial '/' in the path
+          id = env['PATH_INFO'][1..-1]
+
+          # Retrieve the file from FS
+          file = env['useless.fs'].get(BSON::ObjectId(id))
+
+          # and serve it up with the associated content type
+          return [200, {'Content-Type' => file.content_type}, file.read]
+
+        # Two things can go wrong, and they'll both raise an error:
+        #   * the specified ID is not a valid object ID
+        #   * there is no file corresponding to the ID in the FS
+        rescue BSON::InvalidObjectId, Useless::Rack::FS::FileNotFound
+          [404, {'Content-Type' => 'text/plain'}, "File not found: #{id}"]
+        end
+      end
+    end
+  end
+end

data/lib/useless/rack/base.rb

@@ -0,0 +1,20 @@
+module Useless
+  class Rack
+    # Useless::Base is the Rack endpoint for useless.io proper. It has two
+    # responsibilties: show documentation, and serve file from 'useless.fs'.
+    class Base
+      autoload :Doc, 'useless/rack/base/doc'
+      autoload :Files, 'useless/rack/base/files'
+
+      def call(env)
+        # Show platform documentation at root
+        app = ::Rack::URLMap.new '/' => Doc,
+
+          # serve files out of /files/* via the Files Rack endpoint.
+          '/files/'  => Files.new
+
+        app.call(env)
+      end
+    end
+  end
+end

data/lib/useless/rack/doc.rb

@@ -0,0 +1,35 @@
+require 'erb'
+
+module Useless
+  class Rack
+    # `Useless::Doc` is a module that handles serving documentation
+    module Doc
+      TEMPLATE = <<-BLOCK
+<!DOCTYPE html>
+<html>
+<head>
+  <title>useless.io</title>
+  <link href="/application.css" media="screen" rel="stylesheet" type="text/css" />
+</head>
+<body>
+  <div id="container">
+    <%= body %>
+  </div>
+</body>
+</html>
+BLOCK
+
+      def self.serve(file_or_path)
+        # Read the contents of the file or the file at the specified path.
+        body = file_or_path.is_a?(File) ?
+          file_or_path.read : File.read(file_or_path)
+
+        # Render the template,
+        response = ERB.new(TEMPLATE).result(binding)
+
+        # and return it as a Rack response.
+        [200, {'Content-Type' => 'text/html'}, [response]]
+      end
+    end
+  end
+end

data/lib/useless/rack/fs.rb

@@ -0,0 +1,25 @@
+module Useless
+  class Rack
+    # Useless::FS is a minimal wrapper around Mongo::Grid.
+    class FS
+      class FileNotFound < StandardError; end
+
+      def initialize(mongo)
+        @mongo = mongo
+      end
+
+      def put(file, opts = {})
+        @mongo.grid.put(file, opts)
+      end
+
+      def get(id)
+        @mongo.grid.get(id)
+
+      # To preserve the abstraction, raise our own exception when a file isn't
+      # found
+      rescue ::Mongo::GridFileNotFound => e
+        raise FileNotFound, e.message
+      end
+    end
+  end
+end

data/lib/useless/rack/logger.rb

@@ -0,0 +1,50 @@
+require 'logger'
+
+module Useless
+  class Rack
+    # Useless::Logger is a wrapper around Logger for the purposes of decorating.
+    class Logger
+      attr_accessor :request_id
+
+      def initialize(io = $stdout)
+        @logger = ::Logger.new(io)
+      end
+
+      def level=(level)
+        @logger.level = level
+      end
+
+      def level
+        @logger.level
+      end
+
+      def fatal(message)
+        add ::Logger::FATAL, message
+      end
+
+      def error(message)
+        add ::Logger::ERROR, message
+      end
+
+      def warn(message)
+        add ::Logger::WARN, message
+      end
+
+      def info(message)
+        add ::Logger::INFO, message
+      end
+
+      def debug(message)
+        add ::Logger::DEBUG, message
+      end
+
+      private
+
+      def add(level, message)
+        formatted_message = message
+        formatted_message = "[#{@request_id}] #{formatted_message}" if @request_id
+        @logger.add level, formatted_message
+      end
+    end
+  end
+end

data/lib/useless/rack/middleware/assets.rb

@@ -0,0 +1,38 @@
+module Useless
+  class Rack
+    module Middleware
+      # `Assets` maps requests to files in the assets directory.
+      class Assets
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          # If the path couldn't be a file in assets, just proxy the request.
+          unless env['PATH_INFO'] =~ /\/\w+/
+            return @app.call(env)
+          end
+
+          # The path is relative to the assets directory in the gem root
+          path = File.expand_path("../../../../assets#{env['PATH_INFO']}", __FILE__)
+
+          # If there's a corresponding file:
+          if File.exists?(path) and !File.directory?(path)
+            # Try to infer the type from the extension, resorting to 'plain'
+            # if we can't.
+            type = path[/\.(\w+)$/, 1] || 'plain'
+
+            # Read the file,
+            response = File.read(path)
+
+            # and serve it up
+            [200, {'Content-Type' => "text/#{type}"}, [response]]
+          else
+            # Otherwise, just pass the request along
+            @app.call(env)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/useless/rack/middleware/authentication/access_token.rb

@@ -0,0 +1,41 @@
+module Useless
+  class Rack
+    module Middleware
+      module Authentication
+        # The `Authentication::AccessToken` module defines the behavior for access-
+        # token-based authentication middleware. The middlewares are responsible
+        # only for providing the access token via the `#access_token_for_env`
+        # method.
+        module AccessToken
+          def initialize(app)
+            @app = app
+          end
+
+          def call(env)
+            # If we don't already have a user set in the environment,
+            unless env['useless.user']
+              # check to see if an access token was specified.
+              if access_token = access_token_for_env(env)
+                # If so, and a corresponding user can be found,
+                if user = env['useless.mongo']['users'].find_one('access_token' => access_token)
+                  # set 'useless.user' in the environment.
+                  env['useless.user'] = user
+                else
+                  # Otherwise, return a 401 Unauthorized.
+                  return [401, {'Content-Type' => 'text/plain'}, ["Invalid access token: #{access_token}"]]
+                end
+              end
+            end
+
+            @app.call(env)
+          end
+
+          private
+
+          def access_token_for_env(env)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/useless/rack/middleware/authentication/query_string.rb

@@ -0,0 +1,19 @@
+module Useless
+  class Rack
+    module Middleware
+      module Authentication
+        # The `Authentication::QueryString` middleware attempt to retrieve the
+        # access token from the query string.
+        class QueryString
+          include AccessToken
+
+          private
+
+          def access_token_for_env(env)
+            ::Rack::Utils.parse_query(env['QUERY_STRING'])['access_token']
+          end
+        end
+      end
+    end
+  end
+end

data/lib/useless/rack/middleware/authentication/request_header.rb

@@ -0,0 +1,19 @@
+module Useless
+  class Rack
+    module Middleware
+      module Authentication
+        # The `Authentication::RequestHeader` middleware attempts to retrieve the
+        # access token from the `Authorization` request header.
+        class RequestHeader
+          include AccessToken
+
+          private
+
+          def access_token_for_env(env)
+            env['HTTP_AUTHORIZATION']
+          end
+        end
+      end
+    end
+  end
+end

data/lib/useless/rack/middleware/doc.rb

@@ -0,0 +1,17 @@
+module Useless
+  class Rack
+    module Middleware
+      # `Doc` simply adds Useless::Doc instance to env as useless.doc'.
+      class Doc
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          env['useless.doc'] = Useless::Rack::Doc
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/useless/rack/middleware/exceptions.rb

@@ -0,0 +1,41 @@
+module Useless
+  class Rack
+    module Middleware
+      # `Exceptions` is a Rack middleware that handles any exceptions raised by
+      # it's app. It has two responsibilities:
+      #   1. log the exception trace, if a logger is available, and
+      #   2. return a 500 response with the appropriate message
+      class Exceptions
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          @app.call(env)
+        rescue => exception
+          # First, format the exception trace
+          trace = exception.message + "\n" + exception.backtrace.join("\n")
+
+          # If a logger is available,
+          if env['useless.logger']
+            # log the trace as fatal.
+            env['useless.logger'].fatal trace
+          end
+
+          # Next, if the request is authenticated by an admin or we are in development or test,
+          if (env['useless.user'] and env['useless.user']['admin']) or
+              ENV['RACK_ENV'] == 'development'
+            # we will return the trace;
+            message = trace
+          else
+            # otherwise, return a generic message.
+            message = 'An internal server error occurred. Please try again later.'
+          end
+
+          # Finally, return the 500 error.
+          [500, {'Content-Type' => 'text/plain'}, [message]]
+        end
+      end
+    end
+  end
+end

data/lib/useless/rack/middleware/fs.rb

@@ -0,0 +1,17 @@
+module Useless
+  class Rack
+    module Middleware
+      # `FS` simply adds the Useless.fs instance to env as 'useless.fs'.
+      class FS
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          env['useless.fs'] = Useless::Rack.fs
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/useless/rack/middleware/mongo.rb

@@ -0,0 +1,18 @@
+module Useless
+  class Rack
+    module Middleware
+      # `Useless::Mongo` simply adds the Useless.mongo instance to env as
+      # 'useless.mongo'.
+      class Mongo
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          env['useless.mongo'] = Useless::Rack.mongo
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/useless/rack/mongo.rb

@@ -0,0 +1,17 @@
+require 'low/mongo'
+
+module Useless
+  class Rack
+    module Mongo
+      # Returns an instance of the appropriate `Low::Mongo` helper class based upon the
+      # `RACK_ENV` environment variable (or the `env` parameter, if specified).
+      def self.for_env(env = nil)
+        case (env || ENV['RACK_ENV'])
+        when 'test'       then Low::Mongo::Local.new 'useless_test'
+        when 'production' then Low::Mongo::Remote.new ENV['MONGOLAB_URI']
+        else                   Low::Mongo::Local.new 'useless_development'
+        end
+      end
+    end
+  end
+end

data/lib/useless/rack.rb

@@ -0,0 +1,69 @@
+$:.push File.expand_path('../lib', __FILE__)
+
+require 'low/rack/log_level'
+require 'low/rack/rack_errors'
+require 'low/rack/request_id'
+require 'low/rack/request_logger'
+require 'low/rack/subdomain_map'
+require 'low/scoped_logger'
+
+module Useless
+  class Rack
+    autoload :Base, 'useless/rack/base'
+    autoload :Doc, 'useless/rack/doc'
+    autoload :FS, 'useless/rack/fs'
+    autoload :Logger, 'useless/rack/logger'
+    autoload :Mongo, 'useless/rack/mongo'
+
+    module Middleware
+      autoload :Assets, 'useless/rack/middleware/assets'
+      autoload :Doc, 'useless/rack/middleware/doc'
+      autoload :Exceptions, 'useless/rack/middleware/exceptions'
+      autoload :FS, 'useless/rack/middleware/fs'
+      autoload :Mongo, 'useless/rack/middleware/mongo'
+
+      module Authentication
+        autoload :AccessToken, 'useless/rack/middleware/authentication/access_token'
+        autoload :QueryString, 'useless/rack/middleware/authentication/query_string'
+        autoload :RequestHeader, 'useless/rack/middleware/authentication/request_header'
+      end
+    end
+
+    def self.mongo
+      @mongo ||= Mongo.for_env
+    end
+
+    def self.fs
+      @fs ||= FS.new(mongo)
+    end
+
+    def initialize(map = nil, &block)
+      @map = map || {}
+      instance_eval &block if block_given?
+    end
+
+    def map(pair)
+      subdomain, app = pair.first
+      @map[subdomain.to_s] = app.respond_to?(:new) ? app.new : app
+    end
+
+    def call(env)
+      ::Rack::Builder.app do
+        use Middleware::Exceptions
+        use Low::Rack::RequestId
+        use Low::Rack::RackErrors
+        use Low::Rack::LogLevel
+        use Low::Rack::RequestLogger, key: 'useless.logger'
+        use ::Rack::CommonLogger
+        use Middleware::Assets
+        use Middleware::Mongo
+        use Middleware::FS
+        use Middleware::Doc
+        use Middleware::Authentication::QueryString
+        use Middleware::Authentication::RequestHeader
+
+        run Low::Rack::SubdomainMap.new(Base.new, @map)
+      end.call(env)
+    end
+  end
+end

data/lib/useless/version.rb

@@ -0,0 +1,3 @@
+module Useless
+  VERSION = '0.0.6'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,31 @@
+ENV['RACK_ENV'] = 'test'
+require File.dirname(__FILE__) + '/../lib/useless/rack'
+
+require 'rack/mock'
+require 'rack/test'
+
+RSpec.configure do |config|
+  config.order = :rand
+
+  def clean_database
+    Useless::Rack.mongo.db.collections.each do |collection|
+      if !(collection.name =~ /^system\./)
+        collection.drop
+      end
+    end
+  end
+
+  config.before(:suite){ clean_database }
+
+  config.after(:each) do
+    clean_database
+
+    # After dropping collections, we need to force a new connection on the
+    # next request.
+    Useless::Rack.mongo.reset_connection!
+  end
+
+  def asset_path(path)
+    File.dirname(__FILE__) + '/support/assets/' + path
+  end
+end

data/spec/useless/rack/base/files_spec.rb

@@ -0,0 +1,41 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe 'useless.io/files' do
+  include Rack::Test::Methods
+
+  def app
+    Useless::Rack.new
+  end
+
+  describe 'GET /files/:id' do
+    it 'should return a file if one exists for the specified ID' do
+      file = File.open(asset_path('muffin-milk.jpg'))
+      id = Useless::Rack.fs.put(file)
+
+      get Useless::Rack::Base::Files.url_for(id)
+      last_response.should be_ok
+
+      # See spec/useless/fs_spec.rb
+      file.rewind
+      blob = file.read
+      blob.force_encoding('BINARY')
+      blob.should == last_response.body
+    end
+
+    it 'should return a 404 if the file does not exits' do
+      get Useless::Rack::Base::Files.url_for(BSON::ObjectId.new)
+      last_response.should be_not_found
+    end
+
+    it 'should return a 404 if the specified ID is invalid' do
+      get Useless::Rack::Base::Files.url_for('invalid-id')
+      last_response.should be_not_found
+    end
+  end
+
+  describe '.url_for' do
+    it 'should return the appropriate URL for the specified file ID' do
+      Useless::Rack::Base::Files.url_for('abc123').should == 'http://useless.io/files/abc123'
+    end
+  end
+end

data/spec/useless/rack/fs_spec.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Useless::Rack::FS do
+  it 'should allow for files to be added and retrieved via .put and .get' do
+    original_file = File.open(asset_path('muffin-milk.jpg'))
+    original_file_id = Useless::Rack.fs.put(original_file)
+    stored_file = Useless::Rack.fs.get(original_file_id)
+
+    # Useless::Rack::FS stores the file as an un-encoded binary blob, so in order to
+    # compare, we must strip the encoding, i.e. force a binary encoding.
+    original_file.rewind
+    original_blob = original_file.read
+    original_blob.force_encoding('BINARY')
+    original_blob.should == stored_file.read
+  end
+
+  describe '.get' do
+    it 'should raise Useless::FS::FileNotFound if the specified ID doesn\'t exist' do
+      -> { Useless::Rack.fs.get('nonexistant') }.should raise_error(Useless::Rack::FS::FileNotFound)
+    end
+  end
+end

data/spec/useless/rack/logger_spec.rb

@@ -0,0 +1,86 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Useless::Rack::Logger do
+  describe '#fatal' do
+    it 'should emit a fatal message' do
+      io = StringIO.new
+      logger = Useless::Rack::Logger.new(io)
+      logger.fatal 'Oh noes!'
+
+      io.rewind; message = io.read
+      message.should =~ /FATAL/
+      message.should =~ /Oh noes!$/
+    end
+  end
+
+  describe '#error' do
+    it 'should emit an error message' do
+      io = StringIO.new
+      logger = Useless::Rack::Logger.new(io)
+      logger.error 'Wrong!'
+
+      io.rewind; message = io.read
+      message.should =~ /ERROR/
+      message.should =~ /Wrong!$/
+    end
+  end
+
+  describe '#warn' do
+    it 'should emit a warn message' do
+      io = StringIO.new
+      logger = Useless::Rack::Logger.new(io)
+      logger.warn 'Watchout!'
+
+      io.rewind; message = io.read
+      message.should =~ /WARN/
+      message.should =~ /Watchout!$/
+    end
+  end
+
+  describe '#info' do
+    it 'should emit an info message' do
+      io = StringIO.new
+      logger = Useless::Rack::Logger.new(io)
+      logger.info 'Such and such'
+
+      io.rewind; message = io.read
+      message.should =~ /INFO/
+      message.should =~ /Such and such$/
+    end
+  end
+
+  describe '#debug' do
+    it 'should emit a debug message' do
+      io = StringIO.new
+      logger = Useless::Rack::Logger.new(io)
+      logger.debug '101011'
+
+      io.rewind; message = io.read
+      message.should =~ /DEBUG/
+      message.should =~ /101011$/
+    end
+
+    it 'should emit nothing if the level is too high' do
+      io = StringIO.new
+      logger = Useless::Rack::Logger.new(io)
+      logger.level = ::Logger::INFO
+      logger.debug '101011'
+
+      io.rewind; message = io.read
+      message.should == ''
+    end
+  end
+
+  describe '#request_id' do
+    it 'should append the specified ID to all messages' do
+      io = StringIO.new
+      logger = Useless::Rack::Logger.new(io)
+      logger.request_id = 'abc123'
+      logger.info 'Yadda'
+
+      io.rewind; message = io.read
+      message.should =~ /abc123/
+      message.should =~ /Yadda$/
+    end
+  end
+end

data/spec/useless/rack/middleware/authentication/query_string_spec.rb

@@ -0,0 +1,45 @@
+require File.dirname(__FILE__) + '/../../../../spec_helper'
+
+describe Useless::Rack::Middleware::Authentication::QueryString do
+  def authenticated_app
+    app = lambda do |env|
+      body = env['useless.user'] ?
+        "user authenticated: #{env['useless.user']['handle']}" :
+        "unauthenticated"
+
+      [200, {'Content-Type' => 'text/plain'}, [body]]
+    end
+
+    query_string_app = Useless::Rack::Middleware::Authentication::QueryString.new(app)
+    Useless::Rack::Middleware::Mongo.new(query_string_app)
+  end
+
+  it 'should do nothing if `useless.user` is already set' do
+    Useless::Rack.mongo['users'].insert({'handle' => 'dph', 'access_token' => 'def456'})
+    res = Rack::MockRequest.new(authenticated_app).get('/resource?access_token=def456',
+      'useless.user' => {'handle' => 'khy', 'access_token' => 'abc123'})
+    res.should be_ok
+    res.body.should == 'user authenticated: khy'
+  end
+
+  it 'should do nothing if no access token is specified' do
+    res = Rack::MockRequest.new(authenticated_app).get('/resource')
+    res.should be_ok
+    res.body.should == 'unauthenticated'
+  end
+
+  it 'should return a 401 Unauthenticated if an access token is specified, but
+      does not correspond to a user' do
+    res = Rack::MockRequest.new(authenticated_app).get('/resource?access_token=abc123')
+    res.status.should == 401
+    res.body.should == 'Invalid access token: abc123'
+  end
+
+  it 'should set `useless.user` in the environment if a user can be found for
+      the specified access token' do
+    Useless::Rack.mongo['users'].insert({'handle' => 'khy', 'access_token' => 'abc123'})
+    res = Rack::MockRequest.new(authenticated_app).get('/resource?access_token=abc123')
+    res.should be_ok
+    res.body.should == 'user authenticated: khy'
+  end
+end

data/spec/useless/rack/middleware/authentication/request_header_spec.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/../../../../spec_helper'
+
+describe Useless::Rack::Middleware::Authentication::RequestHeader do
+  def authenticated_app
+    app = lambda do |env|
+      body = env['useless.user'] ?
+        "user authenticated: #{env['useless.user']['handle']}" :
+        "unauthenticated"
+
+      [200, {'Content-Type' => 'text/plain'}, [body]]
+    end
+
+    request_header_app = Useless::Rack::Middleware::Authentication::RequestHeader.new(app)
+    Useless::Rack::Middleware::Mongo.new(request_header_app)
+  end
+
+  it 'should do nothing if `useless.user` is already set' do
+    Useless::Rack.mongo['users'].insert({'handle' => 'dph', 'access_token' => 'def456'})
+    res = Rack::MockRequest.new(authenticated_app).get('/resource',
+      'Authorization' => 'def456',
+      'useless.user' => {'handle' => 'khy', 'access_token' => 'abc123'})
+    res.should be_ok
+    res.body.should == 'user authenticated: khy'
+  end
+
+  it 'should do nothing if no access token is specified' do
+    res = Rack::MockRequest.new(authenticated_app).get('/resource')
+    res.should be_ok
+    res.body.should == 'unauthenticated'
+  end
+
+  it 'should return a 401 Unauthenticated if an access token is specified, but
+      does not correspond to a user' do
+    res = Rack::MockRequest.new(authenticated_app).get('/resource', 'HTTP_AUTHORIZATION' => 'abc123')
+    res.status.should == 401
+    res.body.should == 'Invalid access token: abc123'
+  end
+
+  it 'should set `useless.user` in the environment if a user can be found for
+      the specified access token' do
+    Useless::Rack.mongo['users'].insert({'handle' => 'khy', 'access_token' => 'abc123'})
+    res = Rack::MockRequest.new(authenticated_app).get('/resource', 'HTTP_AUTHORIZATION' => 'abc123')
+    res.should be_ok
+    res.body.should == 'user authenticated: khy'
+  end
+end

data/spec/useless/rack/middleware/exceptions_spec.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + '/../../../spec_helper'
+
+describe Useless::Rack::Middleware::Exceptions do
+  it 'should proxy transparently if nothing goes wrong in the main app' do
+    main_app = lambda do |env|
+      [200, {'Content-Type' => 'text/plain'}, ['No Problems!']]
+    end
+    exceptions_app = Useless::Rack::Middleware::Exceptions.new(main_app)
+
+    res = Rack::MockRequest.new(exceptions_app).get('http://useless.info')
+    res.should be_ok
+    res.body.should == 'No Problems!'
+  end
+
+  def broken_app
+    main_app = lambda do |env|
+      raise 'It\'s all broken!'
+      [200, {'Content-Type' => 'text/plain'}, ['No Problems!']]
+    end
+
+    Useless::Rack::Middleware::Exceptions.new(main_app)
+  end
+
+  it 'should return a 500 with a generic message if an exception is raised
+      in the main app and the request is not authenticated' do
+    res = Rack::MockRequest.new(broken_app).get('http://useless.info')
+    res.status.should == 500
+    res.body.should == 'An internal server error occurred. Please try again later.'
+  end
+
+  it 'should return a 500 with details of the exception if one is raised in
+      the main app and the request is authenticated by an admin user' do
+    res = Rack::MockRequest.new(broken_app).get('http://useless.info',
+      'useless.user' => {'handle' => 'khy', 'admin' => true})
+    res.status.should == 500
+    res.body.should =~ /^It's all broken!/
+  end
+
+  it 'should return a 500 with a generic message if an exception is raised
+      in the main app and the request is authenticated by an non-admin user' do
+    res = Rack::MockRequest.new(broken_app).get('http://useless.info',
+      'useless.user' => {'handle' => 'khy'})
+    res.status.should == 500
+    res.body.should == 'An internal server error occurred. Please try again later.'
+  end
+end

data/spec/useless/rack/mongo_spec.rb

@@ -0,0 +1,62 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Useless::Rack::Mongo do
+  describe '.for_env' do
+    it 'should return a instance for \'useless_development\' if \'development\' is specified' do
+      mongo = Useless::Rack::Mongo.for_env('development')
+      mongo.database.should == 'useless_development'
+    end
+
+    it 'should return a instance for \'useless_development\' if RACK_ENV is \'development\'' do
+      original_rack_env = ENV['RACK_ENV']
+      begin
+        ENV['RACK_ENV'] = 'development'
+        mongo = Useless::Rack::Mongo.for_env
+        mongo.database.should == 'useless_development'
+      ensure
+        ENV['RACK_ENV'] = original_rack_env
+      end
+    end
+
+    it 'should return a instance for \'useless_test\' if \'test\' is specified' do
+      mongo = Useless::Rack::Mongo.for_env('test')
+      mongo.database.should == 'useless_test'
+    end
+
+    it 'should return a instance for \'useless_test\' if RACK_ENV is \'test\'' do
+      original_rack_env = ENV['RACK_ENV']
+      begin
+        ENV['RACK_ENV'] = 'test'
+        mongo = Useless::Rack::Mongo.for_env
+        mongo.database.should == 'useless_test'
+      ensure
+        ENV['RACK_ENV'] = original_rack_env
+      end
+    end
+
+    it 'should return a instance for the MONGOLAB_URI if \'production\' is specified' do
+      original_mongolab_uri = ENV['MONGOLAB_URI']
+      begin
+        ENV['MONGOLAB_URI'] = 'mongodb://mongo.com'
+        mongo = Useless::Rack::Mongo.for_env('production')
+        mongo.uri.should == 'mongodb://mongo.com'
+      ensure
+        ENV['MONGOLAB_URI'] = original_mongolab_uri
+      end
+    end
+
+    it 'should return a instance for the MONGOLAB_URL if RACK_ENV is \'production\'' do
+      original_rack_env = ENV['RACK_ENV']
+      original_mongolab_uri = ENV['MONGOLAB_URI']
+      begin
+        ENV['RACK_ENV'] = 'production'
+        ENV['MONGOLAB_URI'] = 'mongodb://mongo.com'
+        mongo = Useless::Rack::Mongo.for_env
+        mongo.uri.should == 'mongodb://mongo.com'
+      ensure
+        ENV['RACK_ENV'] = original_rack_env
+        ENV['MONGOLAB_URI'] = original_mongolab_uri
+      end
+    end
+  end
+end

data/useless.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/useless/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.name          = 'useless'
+  gem.version       = Useless::VERSION
+  gem.summary       = 'The useless.io Ruby library.'
+  gem.description   = 'Library for building a useless.io-compliant APIs in Ruby.'
+
+  gem.authors       = ['Kevin Hyland']
+  gem.email         = ['khy@me.com']
+  gem.homepage      = 'https://github.com/khy/useless.rb'
+
+  gem.files         = `git ls-files`.split($\)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^spec/})
+  gem.require_paths = ['lib']
+
+  gem.add_runtime_dependency 'rack'
+  gem.add_runtime_dependency 'low', '0.0.14'
+  gem.add_runtime_dependency 'mongo'
+  gem.add_runtime_dependency 'bson'
+  gem.add_runtime_dependency 'bson_ext'
+
+  gem.add_development_dependency 'rspec'
+  gem.add_development_dependency 'rack-test'
+end

metadata

@@ -0,0 +1,199 @@
+--- !ruby/object:Gem::Specification
+name: useless
+version: !ruby/object:Gem::Version
+  version: 0.0.6
+  prerelease: 
+platform: ruby
+authors:
+- Kevin Hyland
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-10-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: low
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.14
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.0.14
+- !ruby/object:Gem::Dependency
+  name: mongo
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bson
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bson_ext
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rack-test
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Library for building a useless.io-compliant APIs in Ruby.
+email:
+- khy@me.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- DOC.html
+- Gemfile
+- README.md
+- Rakefile
+- assets/application.css
+- lib/useless/rack.rb
+- lib/useless/rack/base.rb
+- lib/useless/rack/base/doc.rb
+- lib/useless/rack/base/files.rb
+- lib/useless/rack/doc.rb
+- lib/useless/rack/fs.rb
+- lib/useless/rack/logger.rb
+- lib/useless/rack/middleware/assets.rb
+- lib/useless/rack/middleware/authentication/access_token.rb
+- lib/useless/rack/middleware/authentication/query_string.rb
+- lib/useless/rack/middleware/authentication/request_header.rb
+- lib/useless/rack/middleware/doc.rb
+- lib/useless/rack/middleware/exceptions.rb
+- lib/useless/rack/middleware/fs.rb
+- lib/useless/rack/middleware/mongo.rb
+- lib/useless/rack/mongo.rb
+- lib/useless/version.rb
+- spec/spec_helper.rb
+- spec/support/assets/muffin-milk.jpg
+- spec/useless/rack/base/files_spec.rb
+- spec/useless/rack/fs_spec.rb
+- spec/useless/rack/logger_spec.rb
+- spec/useless/rack/middleware/authentication/query_string_spec.rb
+- spec/useless/rack/middleware/authentication/request_header_spec.rb
+- spec/useless/rack/middleware/exceptions_spec.rb
+- spec/useless/rack/mongo_spec.rb
+- useless.gemspec
+homepage: https://github.com/khy/useless.rb
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: The useless.io Ruby library.
+test_files:
+- spec/spec_helper.rb
+- spec/support/assets/muffin-milk.jpg
+- spec/useless/rack/base/files_spec.rb
+- spec/useless/rack/fs_spec.rb
+- spec/useless/rack/logger_spec.rb
+- spec/useless/rack/middleware/authentication/query_string_spec.rb
+- spec/useless/rack/middleware/authentication/request_header_spec.rb
+- spec/useless/rack/middleware/exceptions_spec.rb
+- spec/useless/rack/mongo_spec.rb