dolphy 0.1.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8fbd167c947e2d4bbd1a1b10a985c9c467cd0b0f
+  data.tar.gz: 0a3f510552e4e3a79e5cab2d81831f9aa6098fb1
+SHA512:
+  metadata.gz: 08ab403c88a8e3c710bc72dbe0816813c4a0b70d759acb80d4e9c8e3c0bd2430ff6ab78dcfa379f5d0086e8d27cef8c34c6db7fcecbd816dd3d06343439bfa44
+  data.tar.gz: f0e12935f25aa99a629a1d9fb61774445747717bebc84cd2e3972878e34f9a7fb508ea02a068dc6568746d519f8db66080024c9f93cf2cc68cffa306e3d10aba

data/LICENSE

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

data/README.md

@@ -0,0 +1,98 @@
+# Dolphy
+[![Build Status](https://magnum.travis-ci.com/majjoha/dolphy.svg?token=G5jfvsY2S8tSb5P53rGq)](https://magnum.travis-ci.com/majjoha/dolphy)
+[![Code Climate](https://codeclimate.com/repos/53cb2ea469568031fe01ad3f/badges/a7a6a867bc5744c524d7/gpa.png)](https://codeclimate.com/repos/53cb2ea469568031fe01ad3f/feed)
+
+Dolphy is an incredibly small (~200 LOC) web framework written in Ruby and based
+on Rack. It was originally mimicking the behavior of Sinatra, but as time has
+passed, it has slightly changed direction and is now more of a mix between
+different web frameworks.
+
+It has solely been written for the purpose of learning and is not meant to be
+used in production.
+
+There are a lot of things I want to do to improve the code and functionality of
+this project. I try to list these things in the
+[issues](https://github.com/majjoha/dolphy/issues). Feel free to fork this
+repository and contribute if you want to help me implement features or fixing
+bugs.
+
+## Requirements
+* Ruby 2.1.0 or newer.
+
+## Getting started
+Add this line to your Gemfile:
+
+```ruby
+gem 'dolphy'
+```
+
+And then run:
+
+```
+bundle
+```
+
+Or simply install it yourself as:
+
+```
+gem install dolphy
+```
+
+## Usage
+```ruby
+require 'dolphy'
+
+Dolphy.app do
+  setup do |app|
+    # It is possible to specify the template engine in the config block. If no
+    # template engine is specified, it will simply default to ERB.
+    app.settings[:template_engine] = Dolphy::TemplateEngines::HamlEngine
+
+    # You can also specify a view path where Dolphy will look for views. It is
+    # by default set to `./views/`.
+    app.settings[:view_path] = "./somewhere/else/views/"
+
+    # Configurations are available to the rest of the application defined in the
+    # router block, so we could for instance define a title. Basically, you can
+    # give the settings hash any key value pair that you might find useful to
+    # store for later use.
+    app.settings[:title] = "Building things with Dolphy"
+  end
+
+  Dolphy.router do
+    get '/' do
+      render :index, { title: settings[:title], body: "Hello!" }
+    end
+
+    get '/login' do
+      render :login
+    end
+
+    post '/post' do
+      render :post, body: "hello #{params["message"]["name"]}"
+    end
+
+    get '/hello/:name' do |name|
+      render :hello, name: name
+    end
+  end
+end.serve!
+```
+
+## Inspiration
+I've been looking in my directions for inspiration. I probably owe some credit
+to [Camping](http://camping.io), [Cuba](http://cuba.is),
+[NYNY](http://alisnic.github.io/nyny/), and obviously
+[Sinatra](http://sinatrarb.com) and [Rails](http://rubyonrails.org).
+
+
+## Contribute
+1. [Fork it](https://github.com/majjoha/dolphy/fork).
+2. Create your feature branch (`git checkout -b my-new-feature`).
+3. Commit your changes (`git commit -am 'Add some new feature.'`).
+4. Push to the branch (`git push origin my-new-feature`).
+5. Create a new pull request.
+
+## License
+See [LICENSE](https://github.com/majjoha/dolphy/blob/master/LICENSE).
+Copyright (c) 2014 Mathias Jean Johansen <<mathias@mjj.io>>

data/lib/dolphy/core.rb

@@ -0,0 +1,70 @@
+require 'dolphy/router'
+require 'dolphy/request'
+require 'dolphy/template_engine'
+require 'dolphy/settings'
+require 'dolphy/response'
+require 'forwardable'
+require 'rack'
+
+module Dolphy
+  class Core
+    extend Forwardable
+    include Dolphy::TemplateEngines
+
+    delegate Dolphy::Router::HTTP_METHODS => :router
+
+    attr_accessor :settings
+
+    def initialize(&block)
+      @router   = Dolphy::Router.new
+      @settings = Dolphy::Settings.new
+      instance_eval(&block)
+    end
+
+    def serve!
+      Rack::Server.start(app: self)
+    end
+
+    def setup(&block)
+      instance_eval(&block)
+    end
+
+    def render(template_name, locals = {})
+      Dolphy::TemplateEngine.new(settings[:template_engine],
+                                 settings[:view_path]).
+        render(template_name, locals)
+    end
+
+    def redirect_to(path, status = 302)
+      response.headers["Location"] = path
+      response.status = status
+    end
+
+    def params
+      request.params
+    end
+
+    # The main logic of Dolphy nests inside the call(env) method. It looks up
+    # the route for the current request method in the routes hash, and if it
+    # finds a route that matches the current path, it evaluates the block and
+    # sets the response accordingly.
+    def call(env)
+      @request  = Dolphy::Request.new(env)
+      @response = Dolphy::Response.new
+
+      router.find_route_for(request).each do |matcher, block|
+        if match = router.find_match_data_for(request, with: matcher)
+          response.body << block.call(*match.captures)
+        end
+      end
+
+      response.status = 404 if response.body.empty?
+      response.body << "Page not found." if response.body.empty?
+      response.finish
+    end
+
+    private
+
+    attr_accessor :response, :router, :request
+  end
+end

data/lib/dolphy/request.rb

@@ -0,0 +1,19 @@
+require 'rack'
+
+module Dolphy
+  class Request < Rack::Request
+    attr_accessor :env
+
+    def initialize(env)
+      @env = env
+    end
+
+    def http_method
+      @env['REQUEST_METHOD'].downcase.to_sym
+    end
+
+    def path
+      @env['PATH_INFO']
+    end
+  end
+end

data/lib/dolphy/response.rb

@@ -0,0 +1,16 @@
+module Dolphy
+  class Response
+    attr_accessor :status, :headers, :body
+
+    def initialize(status = 200,
+                   headers = {"Content-type" => "text/html"})
+      @status  = status
+      @headers = headers
+      @body    = []
+    end
+
+    def finish
+      [status, headers, body]
+    end
+  end
+end

data/lib/dolphy/router.rb

@@ -0,0 +1,36 @@
+module Dolphy
+  class Router
+    attr_accessor :routes
+
+    HTTP_METHODS = %i(get post put delete head options patch trace)
+
+    def initialize
+      @routes = Hash.new { |h, k| h[k] = [] }
+    end
+
+    def find_route_for(request)
+      routes[request.http_method]
+    end
+
+    def find_match_data_for(request, with:)
+      trim_trailing_slash(request.path_info).match(with)
+    end
+
+    HTTP_METHODS.each do |verb|
+      define_method(verb) do |path, &block|
+        routes[verb] << [matcher(path), block]
+      end
+    end
+
+    private
+
+    def trim_trailing_slash(string)
+      string.gsub(/\/$/, "")
+    end
+
+    def matcher(path)
+      re = path.gsub(/\:[^\/]+/, "([^\/]+)")
+      %r{\A#{trim_trailing_slash(re)}\z}
+    end
+  end
+end

data/lib/dolphy/settings.rb

@@ -0,0 +1,26 @@
+module Dolphy
+  class Settings
+    attr_accessor :settings
+
+    def initialize
+      @settings = settings_defaults
+    end
+
+    def [](element)
+      settings[element]
+    end
+
+    def []=(key, value)
+      settings[key] = value
+    end
+
+    private
+
+    def settings_defaults
+      {
+        template_engine: Dolphy::TemplateEngines::ErbEngine,
+        view_path: "./views/"
+      }
+    end
+  end
+end

data/lib/dolphy/template_engine.rb

@@ -0,0 +1,22 @@
+require 'tilt'
+require_relative 'template_engines/erb_engine'
+require_relative 'template_engines/haml_engine'
+
+module Dolphy
+  class TemplateEngine
+    include Dolphy::TemplateEngines
+
+    def initialize(template_engine, view_path)
+      @template_engine = template_engine
+      @view_path       = view_path
+    end
+
+    def render(template_name, locals)
+      template_engine.render(template_name, locals, view_path)
+    end
+
+    private
+
+    attr_accessor :template_engine, :view_path
+  end
+end

data/lib/dolphy/template_engines/erb_engine.rb

@@ -0,0 +1,13 @@
+require 'tilt'
+
+module Dolphy
+  module TemplateEngines
+    class ErbEngine
+      def self.render(template_name, locals = {}, view_path = "./views/")
+        path = File.expand_path("#{view_path}#{template_name.to_s}.erb", Dir.pwd)
+        template = Tilt::ERBTemplate.new(path)
+        template.render(Object.new, locals)
+      end
+    end
+  end
+end

data/lib/dolphy/template_engines/haml_engine.rb

@@ -0,0 +1,13 @@
+require 'tilt'
+
+module Dolphy
+  module TemplateEngines
+    class HamlEngine
+      def self.render(template_name, locals = {}, view_path = "./views/")
+        path = File.expand_path("#{view_path}/#{template_name.to_s}.haml", Dir.pwd)
+        template = Tilt::HamlTemplate.new(path)
+        template.render(Object.new, locals)
+      end
+    end
+  end
+end

data/lib/dolphy/version.rb

@@ -0,0 +1,3 @@
+module Dolphy
+  VERSION = "0.1.5"
+end

data/lib/dolphy.rb

@@ -0,0 +1,14 @@
+require 'dolphy/core'
+require 'dolphy/version'
+
+module Dolphy
+  class << self
+    def app(&block)
+      Dolphy::Core.new(&block)
+    end
+
+    def router(&block)
+      yield
+    end
+  end
+end

data/spec/dolphy/core_spec.rb

@@ -0,0 +1,135 @@
+require_relative '../spec_helper'
+
+describe Dolphy::Core do
+  let(:core) do
+    Dolphy::Core.new do
+      get '/' do
+        'test'
+      end
+
+      get '/empty' do
+        ""
+      end
+    end
+  end
+
+  describe "#initialize" do
+    it "is an instance of Dolphy::Core" do
+      expect(core).to be_a(Dolphy::Core)
+    end
+  end
+
+  describe "#setup" do
+    let(:app) do
+      Dolphy::Core.new do
+        setup do |app|
+          app.settings[:title] = "booyah!"
+        end
+
+        get '/' do
+          'test'
+        end
+      end
+    end
+
+    it "configures the app" do
+      expect(app.settings.settings).
+        to eq(
+          {
+            template_engine: Dolphy::TemplateEngines::ErbEngine,
+            view_path: "./views/",
+            title: "booyah!"
+          }
+        )
+    end
+  end
+
+  describe "#render" do
+    let(:app) do
+      Dolphy::Core.new do
+        setup do |app|
+          app.settings[:view_path] = "./spec/views/"
+        end
+      end
+    end
+
+    it "renders the template with the locals" do
+      expect(app.render :what, body: "wat").to eq "wat"
+    end
+  end
+
+  describe "#call" do
+    context "when the page exists" do
+      let(:env) do
+        {
+          "REQUEST_METHOD" => "GET",
+          "PATH_INFO" => "/"
+        }
+      end
+
+      it "returns an array with a status, headers and the response" do
+        expect(core.call(env)).to eq(
+          [200, {"Content-type" => "text/html"}, ['test']]
+        )
+      end
+    end
+
+    context "when the page doesn't exist" do
+      let(:env) do
+        {
+          "REQUEST_METHOD" => "GET",
+          "PATH_INFO" => "/404"
+        }
+      end
+
+      it "returns an array with a status set to 404, headers and the response
+        set to 'Page not found'" do
+        expect(core.call(env)).to(
+          eq [404, {"Content-type" => "text/html"}, ['Page not found.']]
+        )
+      end
+    end
+
+    context "when the page is an empty string" do
+      let(:env) do
+        {
+          "REQUEST_METHOD" => "GET",
+          "PATH_INFO" => '/empty'
+        }
+      end
+
+      it "returns an empty page with a status set to 200" do
+        expect(core.call(env)).to(
+          eq [200, {"Content-type" => "text/html"}, [""]]
+        )
+      end
+    end
+  end
+
+  describe "#redirect_to" do
+    let(:app) do
+      Dolphy::Core.new do
+        get '/' do
+          'test'
+        end
+
+        get '/test' do
+          redirect_to '/'
+        end
+      end
+    end
+
+    let(:env) do
+      {
+        "REQUEST_METHOD" => "GET",
+        "PATH_INFO" => "/test"
+      }
+    end
+
+    it "sets the HTTP status to 302" do
+      expect(app.call(env)).to(
+        eq [302, {"Content-type" => "text/html", "Location" => "/"}, [302]]
+      )
+    end
+  end
+end

data/spec/dolphy/request_spec.rb

@@ -0,0 +1,28 @@
+require_relative '../spec_helper'
+
+describe Dolphy::Request do
+  let(:env) do
+    Dolphy::Request.new({
+      "REQUEST_METHOD" => "GET",
+      "PATH_INFO" => "/"
+    })
+  end
+
+  describe "#initialize" do
+    it "is an instance of Dolphy::Request" do
+      expect(env).to be_a(Dolphy::Request)
+    end
+  end
+
+  describe "#http_method" do
+    it "returns the HTTP method as a lowercase symbol" do
+      expect(env.http_method).to eq :get
+    end
+  end
+
+  describe "#path" do
+    it "returns the path information" do
+      expect(env.path).to eq "/"
+    end
+  end
+end

data/spec/dolphy/response_spec.rb

@@ -0,0 +1,24 @@
+require_relative '../spec_helper'
+require_relative '../../lib/dolphy/response'
+
+describe Dolphy::Response do
+  let(:response) { Dolphy::Response.new }
+
+  describe "#initialize" do
+    it "initializes a response with a status, headers and an empty body" do
+      expect(response.status).to eq 200
+      expect(response.headers).to eq({"Content-type" => "text/html"})
+      expect(response.body).to eq []
+    end
+
+    it "is an instance of Dolphy::Response" do
+      expect(response).to be_a(Dolphy::Response)
+    end
+  end
+
+  describe "#finish" do
+    it "returns an array consisting of the status, headers and body" do
+      expect(response.finish).to eq [200, {"Content-type" => "text/html"}, []]
+    end
+  end
+end

data/spec/dolphy/router_spec.rb

@@ -0,0 +1,76 @@
+require_relative '../spec_helper'
+
+describe Dolphy::Router do
+  let(:router) { Dolphy::Router.new }
+
+  describe "#initialize" do
+    it "initializes an empty router" do
+      expect(router.routes).to eq({})
+    end
+
+    it "is an instance of Dolphy::Router" do
+      expect(router).to be_a(Dolphy::Router)
+    end
+  end
+
+  describe "#find_route_for" do
+    let(:request) do
+      Dolphy::Request.new({
+        "REQUEST_METHOD" => "GET",
+        "PATH_INFO" => "/"
+      })
+    end
+
+    it "returns the block associated with the route" do
+      router.get '/' do
+        'test'
+      end
+
+      expect(router.find_route_for(request).flatten.last.call).to eq "test"
+    end
+  end
+
+  describe "#get" do
+    it "adds a route to the router" do
+      router.get '/' do
+        'test'
+      end
+
+      expect(router.routes[:get].flatten.first).to eq /\A\z/
+      expect(router.routes[:get].flatten.last.call).to eq "test"
+    end
+  end
+
+  describe "#post" do
+    it "adds a route to the router" do
+      router.post '/' do
+        'test'
+      end
+
+      expect(router.routes[:post].flatten.first).to eq /\A\z/
+      expect(router.routes[:post].flatten.last.call).to eq "test"
+    end
+  end
+
+  describe "#put" do
+    it "adds a route to the router" do
+      router.put '/' do
+        'test'
+      end
+
+      expect(router.routes[:put].flatten.first).to eq /\A\z/
+      expect(router.routes[:put].flatten.last.call).to eq "test"
+    end
+  end
+
+  describe "#delete" do
+    it "adds a route to the router" do
+      router.delete '/' do
+        'test'
+      end
+
+      expect(router.routes[:delete].flatten.first).to eq /\A\z/
+      expect(router.routes[:delete].flatten.last.call).to eq "test"
+    end
+  end
+end

data/spec/dolphy/settings_spec.rb

@@ -0,0 +1,35 @@
+require_relative '../spec_helper'
+
+describe Dolphy::Settings do
+  let(:settings) { Dolphy::Settings.new }
+
+  describe "#initialize" do
+    it "initializes an empty configuration hash" do
+      expect(settings.settings).to eq(
+        {
+          template_engine: Dolphy::TemplateEngines::ErbEngine,
+          view_path: "./views/"
+        }
+      )
+    end
+
+    it "is an instance of Dolphy::Settings" do
+      expect(settings).to be_a(Dolphy::Settings)
+    end
+  end
+
+  describe "#[]" do
+    it "finds the selected element from the settings hash" do
+      expect(
+        settings[:template_engine]
+      ).to eq Dolphy::TemplateEngines::ErbEngine
+    end
+  end
+
+  describe "#[]=" do
+    it "sets the key value pair in the settings hash properly" do
+      settings[:checkout] = 12
+      expect(settings[:checkout]).to be 12
+    end
+  end
+end

data/spec/dolphy/template_engine_spec.rb

@@ -0,0 +1,30 @@
+require_relative '../spec_helper'
+
+describe Dolphy::TemplateEngine do
+  let(:template_engine) do
+    Dolphy::TemplateEngine.new(
+      Dolphy::TemplateEngines::ErbEngine,
+      "./spec/views/"
+    )
+  end
+
+  describe "#initialize" do
+    it "is an instance of Dolphy::TemplateEngine" do
+      expect(template_engine).to be_a(Dolphy::TemplateEngine)
+    end
+  end
+
+  describe "#render" do
+    it "renders the page with the locals" do
+      expect(template_engine.render(:what, body: "wat")).to eq "wat"
+    end
+
+    it "renders the page without the locals" do
+      expect(template_engine.render(:not_found, {})).to eq <<-HTML
+<img src="http://upload.wikimedia.org/wikipedia/en/thumb/8/86/Eric_Dolphy.jpg/220px-Eric_Dolphy.jpg" alt="">
+<h1>Dolphy says no!</h1>
+<h2>HTTP 404 Page not found.</h2>
+HTML
+    end
+  end
+end

data/spec/dolphy_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Dolphy do
+  include Rack::Test::Methods
+
+  describe "#get" do
+    it "returns a page saying Hello on a correct path" do
+      visit '/'
+      expect(page).to have_content "Hello"
+    end
+
+    it "does not have this route" do
+      visit '/fail'
+      expect(page).to have_content "Page not found."
+    end
+
+    it "returns regular strings (without calling render)" do
+      visit '/hello'
+      expect(page).to have_content "hello world!"
+    end
+
+    it "returns a page using the input from the matcher" do
+      visit '/hello/davis'
+      expect(page).to have_content "hello davis"
+    end
+  end
+
+  describe "#post" do
+    it "returns a page saying Hello Mathias" do
+      visit '/'
+      fill_in('message[name]', with: 'Mathias')
+      click_button('Submit')
+      expect(page).to have_content "Hello Mathias"
+    end
+  end
+
+  describe "#redirect_to" do
+    it "redirects to the given path" do
+      visit '/wat'
+      expect(current_path).to eq "/hello"
+      expect(page).to have_content "hello world!"
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,52 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'rack/test'
+require 'capybara'
+require './lib/dolphy'
+
+ENV['RACK_ENV'] = 'test'
+
+app = Dolphy.app do
+  setup do |app|
+    app.settings[:template_engine] = Dolphy::TemplateEngines::HamlEngine
+    app.settings[:view_path] = "./spec/views/"
+  end
+
+  Dolphy.router do
+    get '/' do
+      render :index, { title: "booyah!", body: "Hello" }
+    end
+
+    post '/post' do
+      render :post, { body: "Hello #{params["message"]["name"]}" }
+    end
+
+    get '/hello' do
+      "hello world!"
+    end
+
+    get '/wat' do
+      redirect_to '/hello'
+    end
+
+    get '/hello/:name' do |name|
+      "hello #{name}"
+    end
+  end
+end
+
+Capybara.javascript_driver = :webkit
+Capybara.app = app
+
+module SpecHelper
+  include Rack::Test::Methods
+
+  def app
+    Capybara.app
+  end
+end
+
+RSpec.configure do |config|
+  config.include SpecHelper
+  config.include Capybara::DSL
+end

metadata

@@ -0,0 +1,184 @@
+--- !ruby/object:Gem::Specification
+name: dolphy
+version: !ruby/object:Gem::Version
+  version: 0.1.5
+platform: ruby
+authors:
+- Mathias Jean Johansen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-08-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: tilt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: haml
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: erubis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.3.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 10.3.1
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.14'
+- !ruby/object:Gem::Dependency
+  name: capybara
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: capybara-webkit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+description: Dolphy is an incredibly small (~200 LOC) web framework.
+email: mathias@mjj.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/dolphy.rb
+- lib/dolphy/core.rb
+- lib/dolphy/request.rb
+- lib/dolphy/response.rb
+- lib/dolphy/router.rb
+- lib/dolphy/settings.rb
+- lib/dolphy/template_engine.rb
+- lib/dolphy/template_engines/erb_engine.rb
+- lib/dolphy/template_engines/haml_engine.rb
+- lib/dolphy/version.rb
+- spec/dolphy/core_spec.rb
+- spec/dolphy/request_spec.rb
+- spec/dolphy/response_spec.rb
+- spec/dolphy/router_spec.rb
+- spec/dolphy/settings_spec.rb
+- spec/dolphy/template_engine_spec.rb
+- spec/dolphy_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/majjoha/dolphy
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.0
+signing_key: 
+specification_version: 4
+summary: A small and simple web framework.
+test_files:
+- spec/dolphy/core_spec.rb
+- spec/dolphy/request_spec.rb
+- spec/dolphy/response_spec.rb
+- spec/dolphy/router_spec.rb
+- spec/dolphy/settings_spec.rb
+- spec/dolphy/template_engine_spec.rb
+- spec/dolphy_spec.rb
+- spec/spec_helper.rb
+has_rdoc: