RubyGems - tynn - Versions diffs - 2.0.0.beta3 → 2.0.0.beta4 - Mend

tynn 2.0.0.beta3 → 2.0.0.beta4

Files changed (26) hide show

checksums.yaml CHANGED

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1f568dca09bcd12ce698740d952349f3fd5b8384
-  data.tar.gz: bf36f7702d0a0eb6c0684a67429cac3c98b8595c
+  metadata.gz: 4098115e1a01a01f10ae4209a2ffa63d9296cee4
+  data.tar.gz: f7f7fa51ec9c4ac2202f68f2f6425b33454ff46a
 SHA512:
-  metadata.gz: 5791a202646ee5e484d2606da3aa0fec2f9f9c547092fbe3df39e748997b966f3348ad4055654924988967c1af4c5e35f8f4ce07caa57c322595a694e0240b26
-  data.tar.gz: 4c983c263c8c4c0f87317cf3ceda25fbfe63a3cd3dbcb4250d9986d9dad3f52984e971d3ded76d5ef4b0b76fa148c2a6c1bb8020d0476c045ad4374afa3cb478
+  metadata.gz: 28661462ba5afd767a7da093852c67093e18449b63bee21bca0d302c3c632f0c1fe3f709847a12bcb46bcb4a1652babe5f64080e32131f3d0fcd03a09232d4ce
+  data.tar.gz: 3c01a710785c25eceba0af49791c3b265daff653d4107b8bd6029bafcdc45f16a9945eb0ae5430cb0ccce4669e257b92f0f9ddebfaa8c897a04acc98368ae349

data/LICENSE CHANGED

@@ -1,6 +1,6 @@
 The MIT License (MIT)
-Copyright (c) 2015-2016 Francesco Rodríguez and contributors
+Copyright (c) 2015-2016 Francesco Rodriguez
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md CHANGED

@@ -1,96 +1,29 @@
 # Tynn
 [![Build Status](https://travis-ci.org/frodsan/tynn.svg?branch=master)](https://travis-ci.org/frodsan/tynn)
+[![Documentation Status](https://readthedocs.org/projects/tynn/badge/?version=latest)](http://tynn.xyz/en/latest/?badge=latest)
 [![Dependency Status](https://gemnasium.com/badges/github.com/frodsan/tynn.svg)](https://gemnasium.com/github.com/frodsan/tynn)
-[![Code Climate](https://codeclimate.com/github/frodsan/tynn/badges/gpa.svg)](https://codeclimate.com/github/frodsan/tynn)
-A thin library for web development in Ruby.
-* [Getting Started](#getting-started)
-  * [Assumptions](#assumptions)
-  * [Installation](#installation)
-  * [Hello World!](#hello-world)
-  * [Under the Hood](#under-the-hood)
-  * [Tynn on Rack](#tynn-on-rack)
-* [Routing Basics](#routing-basics)
-  * [HTTP Verbs](#http-verbs)
-  * [Matching path segments](#matching-path-segments)
-  * [Capturing path segments](#capturing-path-segments)
-  * [Matching more than paths](#matching-more-than-paths)
-  * [Routing rules](#routing-rules)
-  * [Composing Applications](#composing-applications)
-* [Managing Request and Response](#managing-request-and-response)
-  * [Accessing Request Parameters](#accessing-request-parameters)
-  * [Setting a Status Code](#setting-a-status-code)
-  * [Writting to the Response Body](#writting-to-the-response-body)
-  * [Setting HTTP Headers](#setting-http-headers)
-  * [Redirecting a Request](#redirecting-a-request)
-  * [Halting a Request](#halting-a-request)
-* [Extending Tynn](#extending-tynn)
-  * [Middleware](#middleware)
-  * [Plugins](#plugins)
-  * [Settings](#settings)
-* [Default Plugins](#default-plugins)
-  * [Environments](#environments)
-  * [Method Override](#method-override)
-  * [JSON](#json)
-  * [Rendering Templates](#rendering-templates)
-  * [Static Files](#static-files)
-  * [Sessions](#sessions)
-* [Security](#security)
-  * [Secure Headers](#secure-headers)
-  * [HTTPS](#https)
-* [Testing](#testing)
-* [API Reference](http://api.tynn.xyz/2.0.0)
-* [Troubleshooting](#troubleshooting)
-  * [Application handler is missing](#missing_handler)
-  * [Application middleware is frozen](#frozen_middleware)
-  * [Secret key is required](#no_secret_key)
-  * [Secret key is shorter than 30 characters](#short_secret_key)
-* [Changelog](#changelog)
-* [Development](#development)
-* [Contributing](#contributing)
-* [Build History](#build-history)
-* [License](#license)
-**NOTE. There is an online version of this README at http://tynn.xyz/.**
-## Getting Started
-Tynn is a minimal and flexible library for building JSON web services and web applications in Ruby. It's designed with two main goals: simplicity and extensibility.
-Tynn offers the essentials to handle HTTP requests and also includes mechanisms to easily extend its functionality through [plugins](#plugins) and [middleware][middleware]. Tynn ships with a set of [default plugins](#default-plugins) that you can combine to meet your needs.
-Tynn is not a framework. There is no built-in support for connecting to databases or a common application architecture. This gives you the freedom to choose the appropiate tools for the job at hand.
-Like most web libraries in Ruby, Tynn is built on top of [Rack], a Ruby webserver interface. Because of this, it has the benefits of using existing libraries and a variety of web servers for free.
+Tynn is a simple and flexible library for building JSON web services and web applications in Ruby.
-Tynn takes design cues from other web libraries like [Rails], [Sinatra], and [Cuba].
+## Installation
-### Assumptions
-This section serves as a high-level introduction to the core features of Tynn. It also covers installation and walks through the creation of a simple application. To get the most out of it, it's recommended to have a basic knowledge about Ruby and HTTP.
-### Installation
-Installing Tynn is pretty straightforward. From the command line, use the `gem` command:
+Installing Tynn is pretty straightforward:
 ```
 $ gem install tynn
 ```
-If you prefer to use [Bundler] instead, set up the environment with:
+If you prefer to use [Bundler](http://bundler.io/) instead, set up the environment with:
-```
+```ruby
 $ bundle init
 ```
-Then, update the contents of the generated Gemfile to:
+Then, add this line to the generated Gemfile:
 ```ruby
-source "https://rubygems.org"
-gem "tynn", "~> 2.0"
+gem "tynn"
 ```
 Finally, install the dependencies with:
@@ -99,673 +32,163 @@ Finally, install the dependencies with:
 $ bundle install
 ```
-Now you can create your first Tynn app!
-### Hello World!
+## Hello World!
-Let's start with a minimal application. Open your preferred text editor and enter the following code:
+Here's a minimal application:
 ```ruby
+# config.ru
 require "tynn"
-Tynn.define do
-  on root? do
+class MyApp < Tynn
+  define do
     on get do
       res.write("Hello World!")
     end
   end
 end
-```
-Save this file as `app.rb`. Once you've done so, create another file called `config.ru` with the contents shown below:
-```ruby
-require File.expand_path("app", __dir__)
-run(Tynn)
+run(MyApp)
 ```
-You already have a functional application! The syntax is very readable, but we'll discuss the details in a moment. To see it in action, you need to start a web server. You can do this by typing `rackup` in the command line.
-![Starting a Web Server](https://raw.githubusercontent.com/frodsan/tynn/master/docs/images/rackup.png)
-> **NOTE:** To stop the web server, hit `Ctrl+C` in the terminal window where it's running. To verify that the server has stopped you should see your command prompt cursor again.
-Now open a browser window and navigate to http://localhost:9292 to see the greeting message.
+Start the application with:
-![Hello World!](https://raw.githubusercontent.com/frodsan/tynn/master/docs/images/hello-world.png)
-### Under the hood
-Tynn is all about routing. Routing determines how an application should respond to a client request to a URI (or path) and a specific HTTP request method. In our previous example, that would be the root path (`/`) and the HTTP GET method.
-To get a look on what's happening under the hood, let's see line 4:
-```ruby
-on root? do
-  # ...
-end
 ```
-That's a little taste of what we call routing matchers in Tynn. The purpose of the `on` matcher is to execute the given block only if the given argument returns `true`. In our case, `root?` returns `true` because we are accessing the root path (`/`) from our browser.
-One line below there is another type of matcher:
-```ruby
-on get do
-  res.write("Hello World!")
-end
+$ rackup config.ru
 ```
-Tynn also includes methods for matching all the HTTP verbs (GET, POST, etc.). By default, if there are no other matchers before a verb matcher, it automatically checks that the current request is for the root path. The above example can be written as:
-```ruby
-Tynn.define do
-  on get do
-    res.write("Hello World!")
-  end
-end
-```
-> **Note.** If you're not familiar with the HTTP methods, check out this [Wikipedia page](https://en.wikipedia.org/wiki/Hypertext_Transfer_Protocol#Request_methods).
-### Tynn on Rack
-The last part of the puzzle is the `config.ru` file. As we mentioned earlier, Tynn is built on top of Rack ... but what is Rack?
-Rack deals with HTTP requests. It provides a minimal interface between web servers supporting Ruby and Ruby web frameworks. Without Rack, Tynn would have to implement its own handler for each Ruby web server.
-To run the hello world application you used `rackup`, one of the tools that comes with Rack. To use `rackup`, you need to supply a `config.ru` file. This file connects the Rack interface with our Tynn application through the `run` method.
-```ruby
-run(Tynn)
-```
-Rack also figures out which server you have available in your system. When we used `rackup`, it fired up WEBrick, a web server built into Ruby by default.
-```
-$ rackup
-[2016-05-14 00:25:11] INFO WEBrick 1.3.1
-```
-Most popular web servers, like [Puma], [Unicorn] or [Thin], have built-in support for Rack, and thus support Tynn too. You can read more about Rack visiting their home page: http://rack.github.io/.
-## Routing basics
-This section covers the routing features of Tynn, such as route definitions, composing applications, and so on.
-### HTTP Verbs
-TODO.
-### Matching path segments
-TODO.
-### Capturing path segments
-TODO.
-### Matching more than paths
-TODO.
-### Routing rules
-TODO.
-### Composing Applications
-TODO.
-## Managing Request and Response
-This section covers the many features Tynn provides to handle requests and responses.
-### Accessing Request Parameters
-TODO.
-### Setting a Status Code
-TODO.
-### Writting to the Response Body
-TODO.
+Open a browser window and navigate to <http://localhost:9292> to see the greeting message:
-### Setting HTTP Headers
+![Hello World!](https://raw.githubusercontent.com/frodsan/tynn/master/docs/images/hello-world.png)
-To set HTTP headers in the response, use the `res.headers` hash.
+## Features
-```ruby
-Tynn.define do
-  on get do
-    res.headers["Content-Type"] = "application/json"
-    res.write(JSON.generate(status: "ok"))
-  end
-end
-```
+### Routing
-Default headers for the application can be set through the `:default_headers` setting.
+Tynn is all about routing. Routing determines how an application should respond to a client request to a URI (or path) and a specific HTTP request method.
 ```ruby
-Tynn.set(:default_headers, "Content-Type" => "application/json")
-Tynn.define do
+MyApp.define do
   on get do
-    res.write(JSON.generate(status: "ok"))
+    res.write("GET /")
   end
-end
-```
-### Redirecting a Request
-To redirect a request to a different location, use `res.redirect`.
-```ruby
-res.redirect("/pricing")
-```
-To redirect to a different site, use a fully-qualified URL.
-```ruby
-res.redirect("https://google.com")
-```
-By default, the status code is set to `302` (Found). To set a different status code, pass an integer as a second parameter.
-```ruby
-res.redirect("/projects/1", 301)
-```
-### Halting a Request
-To immediately stop a request within a route, you can use the `halt` method.
-```ruby
-halt([status, headers, body])
-```
-Use `res.finish` to return a response as per Rack's specification.
-```ruby
-if current_user.nil?
-  res.redirect("/login")
-  halt(res.finish)
-end
-# This won't be reached if current_user is nil
-```
-## Extending Tynn
-TODO.
-### Middleware
-Tynn runs on [Rack](https://github.com/rack/rack). Therefore it is possible
-to use Rack middleware in Tynn. This is how you add a middleware (for example
-`YourMiddleware`) to your app:
-```ruby
-Tynn.use(YourMiddleware)
-```
-You can use any Rack middleware to your app, it is not specific to Tynn. You
-can find a list of Rack middleware [here][middleware].
-[middleware]: https://github.com/rack/rack/wiki/list-of-middleware
-### Plugins
-A way to extend Tynn is to use the plugin API. A plugin is just a module which can contain any of the following rules:
-- If a `ClassMethods` module is defined, it extends the application class.
-- If a `InstanceMethods` module is defined, it's included in the application.
-- If a `setup` method is defined, it will be called last. This method can be used to configure the plugin.
-The following is a complete example of the plugin API.
-```ruby
-require "valuta"
-module CurrencyHelper
-  def self.setup(app, currency: "$")
-    self.currency = currency
-  end
-  module ClassMethods
-    def currency
-      @currency
-    end
-    def currency=(currency)
-      @currency = currency
+  on "posts" do
+    on get do
+      res.write("GET /posts")
     end
-  end
-  module InstanceMethods
-    def to_currency(value)
-      Valuta.convert(value, prefix: self.class.currency)
+    on post do
+      res.write("POST /posts")
     end
-  end
-end
-```
-To load the plugin into the application, use the `plugin` method.
-```ruby
-App.plugin(CurrencyHelper, currency: "$")
-```
-Here is the plugin in action:
-```ruby
-App.currency # => "$"
-App.define do
-  on get do
-    res.write(to_currency(4567))
-  end
-end
-# GET / => 200 $4,567
-```
-### Settings
+    on :id do |id|
+      @post = Post[id]
-Each application has a `settings` hash where configuration can be stored. By default, settings are inherited.
+      on post.nil? do
+        res.status = 404
+        res.write("Not found")
+      end
-```ruby
-Tynn.set(:layout, "layout")
-class Guests < Tynn; end
-class Users < Tynn; end
-class Adminds < Tynn; end
-Users.set(:layout, "users/layout")
-Admins.set(:layout, "admins/layout")
-Guests.settings[:layout] # => "layout"
-Users.settings[:layout]  # => "users/layout"
-Admins.settings[:layout] # => "admins/layout"
-```
+      on get do
+        res.write("GET /posts/#{ @post.id }")
+      end
-This features comes in handy when authoring plugins.
+      on put do
+        res.write("PUT /posts/#{ @post.id }")
+      end
-```ruby
-module CurrencyHelper
-  module ClassMethods
-    def currency=(currency)
-      set(:currency, currency)
-    end
+      on patch do
+        res.write("PATCH /posts/#{ @post.id }")
+      end
-    def currency
-      settings.fetch(:currency, "$")
+      on delete do
+        res.write("DELETE /posts/#{ @post.id }")
+      end
     end
   end
 end
 ```
-## Default Plugins
-Tynn ships with a set of default plugins. The following sections cover the default plugins and extensions shipped with Tynn.
+### Composition
-### Environments
-Tynn ships with [Tynn::Environment] to set and check the current environment for the application.
+You can mount an application inside another. This adds the possibility to run modular applications.
 ```ruby
-require "tynn"
-require "tynn/environment"
-Tynn.plugin(Tynn::Environment)
-```
-The default environment is based on the `RACK_ENV` environment variable.
-```ruby
-ENV["RACK_ENV"]
-# => "test"
-Tynn.environment
-# => :test
-```
-If `ENV["RACK_ENV"]` is `nil`, the default value is `:development`.
-```ruby
-Tynn.environment
-# => :development
-```
-To change the current environment, use the `environment=` method.
-```ruby
-Tynn.environment = :development
-Tynn.environment
-# => :development
-```
-To check the current environment, use: `development?`, `test?`,
-`production?` or `staging?`.
-```ruby
-Tynn.plugin(Tynn::SSL) if Tynn.production?
-```
-Perform operations on specific environments with the `configure` method.
-```ruby
-Tynn.configure(:development) do |app|
-  app.use(Tynn::Static, %w(/js /css /images))
+class Posts < MyApp
 end
-Tynn.configure(:production) do |app|
-  app.use(Tynn::SSL)
-end
-```
-### JSON
-Tynn ships with [Tynn::JSON] to serve JSON resources. It adds a helper method, called `json`, that generates a JSON document and writes it to the response body. This also automatically sets the content type header to `application/json`.
-```ruby
-require "tynn"
-require "tynn/json"
-Tynn.define do
-  on "array" do
-    on get do
-      json(["foo", "bar", "baz"])
-    end
+Posts.define do
+  on get do
+    res.write("GET /posts")
   end
-  on "object" do
-    on get do
-      json(foo: "bar")
-    end
-  end
+  # ...
 end
-```
-### Rendering Templates
-TODO.
-### Method Override
-HTML Forms only support GET and POST requests. To perform other actions such as PUT, PATCH or DELETE, use the [Rack::MethodOverride] middleware. Note that there is no need to add any new dependencies to the application as it's included in Rack already.
-```ruby
-Tynn.use(Rack::MethodOverride)
-```
-This uses a POST form to simulate a request with a non-supported method. In order to succeed, a hidden input field, with the name `_method` and the method name as the value, needs to be included. The following example simulates a PUT
-request.
-```html
-<form method="POST" action="/posts/1">
-  <input type="hidden" name="_method" value="PUT">
-  <!-- ... -->
-</form>
-```
-Now, this will trigger the `put` matcher in the application.
-```ruby
-Posts.define do
-  on put do
-    post.update(req.params["post"])
+MyApp.define do
+  on "posts" do
+    run(Posts)
   end
 end
 ```
-### Static Files
-Tynn ships with [Tynn::Static] to serve static files such as images, CSS, JavaScript and others.
-```ruby
-require "tynn"
-require "tynn/static"
-Tynn.plugin(Tynn::Static, %w(/js /css /images))
-```
-By default, static files are served from the folder `public` in the current directory. You can specify a different location by passing the `:root` option:
-```ruby
-Tynn.plugin(Tynn::Static, %w(/js /css /images), root: "assets")
-```
-As you can see in the table below, the name of static directory is not included in the URL because the files are looked up relative to that directory.
+Settings and extensions are inherited by the subclasses.
-| File                         | URL                                    |
-| ---------------------------- | -------------------------------------- |
-| ./public/js/application.js   | http://example.org/js/application.js   |
-| ./public/css/application.css | http://example.org/css/application.css |
-| ./public/images/logo.png     | http://example.org/images/logo.png     |
+### Plugins & Middleware
-It's important to mention that the path of the static directory path is relative to the directory where you run the application. If you run the application from another directory, it's safer to use an absolute path:
-```ruby
-Tynn.plugin(
-  Tynn::Static,
-  %w(/js /css /images),
-  root: File.expand_path("public", __dir__)
-)
-```
-### Sessions
-TODO.
-## Security
-Many of the default plugins include secure default options. Here are some plugins that can improve the security of your web application.
-### Secure Headers
-Tynn ships with the [Tynn::SecureHeaders] plugin.
+Tynn includes mechanisms to easily extend its functionality through plugins and middleware. It also ships with a set of [default plugins][documentation] that you can combine to meet your needs:
 ```ruby
 require "tynn"
+require "tynn/environments"
+require "tynn/json"
 require "tynn/secure_headers"
+require "tynn/ssl"
-Tynn.plugin(Tynn::SecureHeaders)
-```
-This plugins adds the following security related HTTP headers to each response.
-- **X-Content-Type-Options:** Prevents IE and Chrome from [Content Type Sniffing][sniffing]. Defaults to `"nosniff"`.
-- **X-Frame-Options:** Provides [Clickjacking] protection. Defaults to `"deny"`.
-- **X-XSS-Protection:** Enables the XSS protection filter built into IE, Chrome and Safari. This filter is usually enabled by default, the use of this header is to re-enable it if it was turned off by the user. Defaults to `"1; mode=block"</tt`.
-You can configure the default headers through the `:default_headers` setting.
-```ruby
-Tynn.set(:default_headers, {
-  "X-Frame-Options" => "sameorigin"
-})
-```
-### HTTTPS
-TODO.
-## Testing
-Tynn ships with [Tynn::Test], a simple helper class to simulate requests to your application.
-```ruby
-require "tynn"
-require "tynn/test"
-Tynn.define do
-  on get do
-    res.write("hei")
-  end
+class MyApp < Tynn
+  plugin(Tynn::Environments)
+  plugin(Tynn::JSON)
+  plugin(Tynn::SecureHeaders)
+  plugin(Tynn::SSL, Tynn.production?)
 end
-ts = Tynn::Test.new
-ts.get("/")
-200   == ts.res.status    # => true
-"hei" == ts.res.body.join # => true
-```
-[Tynn::Test] is test-framework agnostic. The following example uses [Minitest]:
-```ruby
-require "minitest/autorun"
-require "tynn/test"
-class GuestsRouteTest < Minitest::Test
-  def setup
-    @ts = Tynn::Test.new
-  end
-  def test_home
-    @ts.get("/")
-    assert_equal 200, @ts.res.status
-    assert_equal "Hello World!", @ts.res.body.join
-    assert_equal "text/html", @ts.res.headers["Content-Type"]
+MyApp.define do
+  on get do
+    json(message: "Hello World!")
   end
 end
 ```
-If this is not of your flavor, you can use any Rack-based testing library or framework, like: [Rack::Test] or [Capybara].
-## Troubleshooting
-If you have problems with running Tynn, see below or [ask in GitHub Issues](https://github.com/frodsan/tynn/issues/new).
-* <a name="missing_handler"></a>
-  **Application handler is missing**
-  <sup>[[link](#missing_handler)]</sup>
-  Application handler is probably not set. Try `#define`:
-  ```ruby
-  MyApp.define do
-    # ...
-  end
-  run(MyApp)
-  ```
-* <a name="frozen_middleware"></a>
-  **Application middleware is frozen**
-  <sup>[[link](#frozen_middleware)]</sup>
-  Application middleware is frozen when application handler is set. Please, set the middleware before setting the application handler.
-  ```ruby
-  # bad
-  MyApp.define do
-    # ...
-  end
-  MyApp.use(Middleware)
-  # good
-  MyApp.use(Middleware)
+Tynn includes plugins to manage sessions, serve static files, render view templates, and so on.
-  MyApp.define do
-    # ...
-  end
-  ```
-* <a name="no_secret_key"></a>
-  **Secret key is required**
-  <sup>[[link](#no_secret_key)]</sup>
-  [Tynn::Session] uses a secret key to sign the cookie's data, thus unauthorized means can't alter it. Please, add the secret option to your code:
-  ```ruby
-  MyApp.plugin(Tynn::Session, secret: "__change_me__", ...)
-  ```
-  If you're sharing your code publicly, make sure the secret key is kept private. Knowing the secret allows an attacker to tamper the data. You can use environment variables to store the secret key:
-  ```ruby
-  MyApp.plugin(Tynn::Session, secret: ENV.fetch("SESSION_SECRET"), ...)
-  ```
-* <a name="short_secret_key"></a>
-  **Secret key is shorter than 30 characters**
-  <sup>[[link](#short_secret_key)]</sup>
-  The secret provided is shorter than the minimum length. Make sure the secret is long and all random. You can generate a secure secret key with:
-  ```
-  $ ruby -r securerandom -e "puts SecureRandom.hex(64)"
-  929234f24e8c7450166a88142a...
-  ```
+### Rack Ecosystem
-## Changelog
+Like most web libraries in Ruby, Tynn is built on top of [Rack](http://rack.github.io/), a Ruby webserver interface. Because of this, it has the benefits of using existing libraries and a variety of web servers for free, like [Puma](http://puma.io/) or [Unicorn](https://unicorn.bogomips.org/).
-To learn about new features, bug fixes, and changes, please refer to the [CHANGELOG](https://github.com/frodsan/tynn/blob/master/CHANGELOG.md).
+### Security by default
-## Development
+In addition to the security-related plugins shipped with Tynn, all the plugins provide secure options by default, like escaping HTML unsafe characters, CSRF protection, preventing session tampering, etc.
-Fork the project with:
-```
-$ git clone git@github.com:frodsan/tynn.git
-```
+## Getting Started
-To install dependencies, use:
+You can read more about Tynn in the [official documentation][documentation].
-```
-$ bundle install
-```
-To run the test suite, do:
+## Compatibility
-```
-$ rake test
-```
+Tynn supports Ruby 2.3+ and Rack 2.0+.
 ## Contributing
-Use [GitHub Issues](https://github.com/frodsan/tynn/issues) for reporting bugs, discussing features and general feedback. If you've found a problem in Tynn, be sure to check the [past issues](https://github.com/frodsan/tynn/issues?state=closed) before open a new one.
+If you'd like to contribute to Tynn, check the [contribution guidelines](https://github.com/frodsan/tynn/blob/master/docs/contributing.md).
-## Build History
+## Inspiration
-[![Build History](https://buildstats.info/travisci/chart/frodsan/tynn?branch=master)](https://travis-ci.org/frodsan/tynn/builds)
+Tynn takes design cues from other web libraries like [Rails](http://rubyonrails.org/), [Sinatra](http://www.sinatrarb.com/), and [Cuba](http://cuba.is/).
 ## License
 Tynn is released under the [MIT License](http://www.opensource.org/licenses/MIT).
-[bundler]: http://bundler.io/
-[capybara]: https://github.com/jnicklas/capybara
-[clickjacking]: https://www.owasp.org/index.php/Clickjacking
-[cuba]: http://cuba.is/
-[minitest]: https://github.com/seattlerb/minitest
-[puma]: http://puma.io/
-[rack]: http://rack.github.io/
-[rack::test]: https://github.com/brynary/rack-test
-[rack::methodoverride]: http://www.rubydoc.info/github/rack/rack/Rack/MethodOverride
-[rails]: http://rubyonrails.org/
-[sinatra]: http://www.sinatrarb.com/
-[sniffing]: https://msdn.microsoft.com/library/gg622941(v=vs.85).aspx
-[thin]: http://code.macournoyer.com/thin/
-[tynn::environment]: http://api.tynn.xyz/2.0.0/Tynn/Environment.html
-[tynn::json]: http://api.tynn.xyz/2.0.0/Tynn/JSON.html
-[tynn::render]: http://api.tynn.xyz/2.0.0/Tynn/Render.html
-[tynn::secureheaders]: http://api.tynn.xyz/2.0.0/Tynn/SecureHeaders.html
-[tynn::session]: http://api.tynn.xyz/2.0.0/Tynn/Session.html
-[tynn::static]: http://api.tynn.xyz/2.0.0/Tynn/Static.html
-[tynn::test]: http://api.tynn.xyz/2.0.0/Tynn/Test.html
-[unicorn]: https://unicorn.bogomips.org/
+[documentation]: http://tynn.readthedocs.io/en/latest/