jeanine 0.4.0 → 0.7.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA256:
-  metadata.gz: d62b1858b952c8c8b7575f4a5c8ff60d9401e846d6d9fe9d302573052715706c
-  data.tar.gz: fd9d260653e2164bd98fc333dedcbfedf1e58fd0f7feb33d84435406668a76df
+SHA1:
+  metadata.gz: 00f439386000e4e03fde175cf305429a84809cc0
+  data.tar.gz: 2c19abd0a152c6240c2e57beb0cf3cedf520ed93
 SHA512:
-  metadata.gz: bcfb247647f312eb473cf7681b1415dd7cdd828f545711cdb5e7cf641c69127d832617e952ece9f83daf1c09e391624efc70acd7259aa3ad1d168a01b93aa135
-  data.tar.gz: 6afa5f33deb9c2a2094e317bdd5b755aa184a97c7378da944cc73968c4069d17b3e8c37b8f996efb7cd81b8af115aaed13406e45afd9bd5e1382225513c44bbc
+  metadata.gz: 205ed5845e02c18b59014cc5616f0fadc0f67b448a45c0cfcded08af17516a7e0b1beba07cb107a2a9dda2232b6404112b65dda00aecf0b97569df44bb15a030
+  data.tar.gz: 0f4fff626a3151825c605026bb68cafcf701aa05753fb06ac76086fc79f7b9e83ce975a51d4fc161e75cd0672dcfde975b4b4bcd343113923754a24ef09e5c19

data/README.md

@@ -0,0 +1,228 @@
+# Jeanine
+
+A Ruby micro-web-framework that gives you enough training wheels to be productive, while being as nearly as fast as Rack itself.
+
+Its design (and some parts of the code) is influenced by/inherited from (thanks!) Ruby on Rails, Rack::App, Hobbit, and Cuba. Without them this is nothing.
+ 
+## Name 
+
+Named after my mom. Because she was the best.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'jeanine'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install jeanine
+
+## Basic usage
+
+Drop this into `config.ru`:
+
+```ruby
+require 'bundler/setup'
+require 'jeanine'
+
+class App < Jeanine::App
+  root do
+    "Hello world"
+  end
+end
+
+run App 
+```
+
+`$ rackup`
+
+## Advanced usage 
+
+```ruby
+class App < Jeanine::App 
+  path "/posts" do 
+    get do 
+      if request.json?
+        render json: []
+      else
+        "Posts index"
+      end
+    end 
+    get "new" do 
+      "Posts new"
+    end
+    post do 
+      "Posts post"
+    end 
+    path ":id" do 
+      get do 
+        "Posts #{params[:id]}"
+      end
+      match via: [:put, :patch] do 
+        "Posts #{request.via} #{params[:id]}"
+      end
+      delete do
+        "Posts delete #{params[:id]}" 
+      end 
+      path "/comments" do
+        get do 
+          "Posts #{params[:id]} comments"
+        end 
+      end
+    end 
+  end 
+end 
+```
+
+## Plugins 
+
+### Callbacks 
+
+Supports `before` and `after` callbacks (same DSL): 
+
+```
+class App < Jeanine::App
+  plugin :Callbacks 
+  before do 
+    puts "All"
+  end
+  before /posts/ do
+    puts "Before posts"
+  end 
+  before /posts\/\d*/, /comments\/\d*/  do 
+    puts "Before posts/:id, comments/:id"
+    response.headers['X-Thing-Id'] = params[:id]
+  end 
+end 
+```
+
+### Rendering
+
+Basic support for rendering. Be explicit.
+
+```ruby 
+class App < Jeanine::App
+  plugin :Rendering 
+  # loads views/root.html.erb and views/layouts/application.html.erb
+  root do 
+    @title = "My cool app"
+    render template: "root.html.erb", layout: "application.html.erb"
+  end
+end 
+```
+
+### Sessions
+
+Uses Rack's session management.
+
+```ruby 
+class App < Jeanine::App
+  plugin :Session
+  root do 
+    session[:uid] = SecureRandom.hex
+  end
+end 
+```
+
+### Error handling
+
+```ruby 
+class App < Jeanine::App
+  plugin :Resucable 
+  rescue_from NoMethodError, RuntimeError do |exception|
+    response.status = 500
+    "Oh no!"
+  end
+  rescue_from StandardError, with: :handle_error!
+  root do 
+    @title = "My cool app"
+    raise NoMethodError 
+    render template: "root.html.erb", layout: "application.html.erb"
+  end
+
+  private 
+  
+  def handle_error!(exception)
+    response.status = 500
+    render template: "error.html.erb" 
+  end
+end 
+```
+
+## Development
+
+### Ideologies
+
+* No meaningless metaprogramming = fast 
+
+## Benchmarks 
+
+### Requests/second
+
+Benched on a Intel Core i7-8700B / 64GB RAM.
+
+```
+Framework            Requests/sec  % from best
+----------------------------------------------
+rack                     17299.31      100.00%
+jeanine                  16022.71       92.62%
+rack-response            15462.50       89.38%
+syro                     15416.13       89.11%
+watts                    15307.52       88.49%
+roda                     14550.56       84.11%
+hanami-router            14342.92       82.91%
+cuba                     14246.23       82.35%
+hobbit                   14132.20       81.69%
+rambutan                 12526.40       72.41%
+rack-app                 11696.66       67.61%
+flame                     7931.61       45.85%
+rails-metal               7761.75       44.87%
+sinatra                   4616.81       26.69%
+grape                     2401.66       13.88%
+hobby                     1805.93       10.44%
+rails-api                 1593.77        9.21%
+```
+
+### Memory
+
+```
+Framework       Allocs/Req Memsize/Req
+--------------------------------------
+rack                    40        3408
+roda                    43        4016
+syro                    44        4288
+cuba                    44        4056
+watts                   46        3648
+hobbit                  48        4416
+jeanine                 52        4576
+hobby                   52        5416
+rack-response           55        5128
+rails-metal             59        5848
+hanami-router           63        5184
+rambutan                79        6944
+rack-app                80        8424
+flame                  115        9648
+sinatra                179       13440
+grape                  250       26704
+rails-api              383       34949
+```
+
+## Todo 
+
+* Callback constraints 
+* File downloads 
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/joshmn/jeanine.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/exe/jeanine

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/jeanine/cli'
+
+Jeanine::CLI.new(ARGV).execute

data/lib/jeanine.rb

@@ -1,18 +1,14 @@
+require 'rack'
+
 require 'forwardable'
 require 'logger'
 
 require "jeanine/version"
 require 'jeanine/core_ext'
-require 'jeanine/router'
-require 'jeanine/app'
-require 'tilt'
 
 module Jeanine
-  def self.view_paths
-    @_view_paths ||= Set.new(["views"])
-  end
-  def self.tilt_cache
-    @title_cache ||= Tilt::Cache.new
+  def self._installed_plugins
+    @_installed_plugins ||= []
   end
 
   def self.logger
@@ -26,4 +22,7 @@ module Jeanine
   def self.router
     @router ||= Router.new
   end
+
+  autoload :Router,   'jeanine/router'
+  autoload :App,   'jeanine/app'
 end

data/lib/jeanine/app.rb

@@ -1,26 +1,35 @@
-require 'jeanine/callbacks'
 require 'jeanine/mimes'
 require 'jeanine/request'
-require 'jeanine/rescuing'
 require 'jeanine/response'
-require 'jeanine/renderer'
 require 'jeanine/routing'
-require 'jeanine/session'
-require 'jeanine/view_paths'
 
 module Jeanine
   class App
-    include Session
-    include Rescuing
     include Routing::Evaluation
 
     attr_reader :request, :response
 
+    def self.plugin(name)
+      unless Jeanine._installed_plugins.include?(name)
+        unless const_defined?("Jeanine::#{name}")
+          require "jeanine/#{name.to_s.underscore}"
+        end
+        include Kernel.const_get("Jeanine::#{name}")
+        Jeanine._installed_plugins << name
+      end
+    end
+
+    def self.installed_plugins
+      Jeanine._installed_plugins
+    end
+
+    # plugin :Callbacks
+    # plugin :Rendering
+    # plugin :Rescuing
+    # plugin :Session
+
     class << self
-      include Callbacks
       include Routing::DSL
-      include Rescuing
-      include ViewPaths
 
       alias :_new :new
       def new(*args, &block)
@@ -47,21 +56,10 @@ module Jeanine
     end
 
     def call(env)
-      begin
-        @env = env
-        @request = Jeanine::Request.new(env)
-        @response = Jeanine::Response.new
-        catch(:halt) { route_eval }
-      rescue => error
-        handler = self.class.rescue_handlers[error.class]
-        raise error unless handler
-        if handler.is_a?(Symbol)
-          @response.write(send(handler, error))
-        else
-          @response.write(instance_exec(error, &handler))
-        end
-        @response.complete!
-      end
+      @env = env
+      @request = Jeanine::Request.new(env)
+      @response = Jeanine::Response.new
+      catch(:halt) { route_eval }
     end
 
     private
@@ -74,11 +72,6 @@ module Jeanine
                   end
     end
 
-    def render(*args)
-      @response.action_variables = instance_variables_cache
-      Renderer.new(@response).render(*args)
-    end
-
     def instance_variables_cache
       instance_variables.each_with_object({}) do |var, obj|
         obj[var] = instance_variable_get(var)

data/lib/jeanine/callbacks.rb

@@ -1,28 +1,105 @@
 module Jeanine
   module Callbacks
-    def _callbacks
-      @_callbacks ||= {
-          before: [],
-          after: [],
-          before_all: [],
-          after_all: []
-      }
+    def self.included(klass)
+      klass.extend InstanceMethods
+      klass.prepend EvaluationMethods
     end
 
-    def before(*paths, &block)
-      _register_callback(:before, paths, &block)
-    end
+    module InstanceMethods
+      def _callbacks
+        @_callbacks ||= {
+            before: [],
+            after: [],
+            before_all: [],
+            after_all: []
+        }
+      end
+
+      def before(*paths, &block)
+        _register_callback(:before, paths, &block)
+      end
+
+      def after(*paths, &block)
+        _register_callback(:after, paths, &block)
+      end
+
+      private
 
-    def after(*paths, &block)
-      _register_callback(:after, paths, &block)
+      def _register_callback(type, paths = [], &block)
+        if paths == []
+          _callbacks["#{type}_all".to_sym] << { block: block }
+        else
+          _callbacks[type] << { paths: paths, block: block }
+        end
+      end
     end
 
-    private
-    def _register_callback(type, paths = [], &block)
-      if paths == []
-        _callbacks["#{type}_all".to_sym] << { block: block }
-      else
-        _callbacks[type] << { paths: paths, block: block }
+    module EvaluationMethods
+      def route_eval
+        before_find_route!
+        route = find_route
+
+        if route
+          before_evaluate_route!
+          result = instance_eval(&route[:block])
+          @response.write(result)
+          after_evaluate_route!
+        else
+          @response.status = 404
+        end
+        after_response!
+        @response.complete!
+      end
+
+      private
+
+      def before_find_route!
+        run_before_callbacks!(:before_all)
+      end
+
+      def before_evaluate_route!
+        run_before_callbacks!(:before)
+      end
+
+      def after_evaluate_route!
+        run_after_callbacks!(:after)
+      end
+
+      def after_response!
+        run_after_callbacks!(:after_all)
+      end
+
+      def run_before_callbacks!(type)
+        if type == :before_all
+          self.class._callbacks[type].each { |callback| eval_callback(&callback[:block]) }
+        else
+          matching_callbacks(type) do |callback|
+            eval_callback(&callback[:block])
+          end
+        end
+      end
+
+      def run_after_callbacks!(type)
+        if type == :after_all
+          self.class._callbacks[type].each { |callback| eval_callback(&callback[:block]) }
+        else
+          matching_callbacks(type) do |callback|
+            eval_callback(&callback[:block])
+          end
+        end
+      end
+
+      def matching_callbacks(type)
+        self.class._callbacks[type].select do |callback|
+          paths = callback[:paths]
+          if paths.detect { |path| path.match?(@request.path_info) }
+            yield callback
+          end
+        end
+      end
+
+      def eval_callback(*args, &callback)
+        instance_exec(*args, &callback)
       end
     end
   end

data/lib/jeanine/cli.rb

@@ -0,0 +1,32 @@
+require 'fileutils'
+
+module Jeanine
+  class CLI
+    def initialize(args)
+      @args = args
+    end
+
+    def execute
+      if @args[0] == 'new'
+        command_new!
+      else
+        $stdout.puts "I don't know how to `#{@args[0]}`. Maybe you meant `new`?"
+      end
+    end
+
+    def command_new!
+      FileUtils.mkdir("#{@args[1]}") unless Dir.exists?("#{@args[1]}")
+      FileUtils.mkdir("#{@args[1]}/config") unless Dir.exists?("#{@args[1]}/config")
+      relative_dir = "lib/jeanine/generator/new"
+      Dir.glob("lib/jeanine/generator/new/**/*.*").each do |file|
+        new_dir = file.gsub(relative_dir, "#{@args[1]}")[0...-3]
+        FileUtils.copy_file(file, new_dir)
+      end
+      relative_dir = "lib/jeanine/generator/new/config"
+      Dir.glob("lib/jeanine/generator/new/config/**/*.*").each do |file|
+        new_dir = file.gsub(relative_dir, "#{@args[1]}/config")[0...-3]
+        FileUtils.copy_file(file, new_dir)
+      end
+    end
+  end
+end

data/lib/jeanine/core_ext/hash.rb

@@ -5,4 +5,19 @@ class Hash
   def reverse_merge!(other_hash)
     replace(reverse_merge(other_hash))
   end
+  def deep_transform_keys(&block)
+    result = {}
+    each do |key, value|
+      result[yield(key)] = value.is_a?(Hash) ? value.deep_transform_keys(&block) : value
+    end
+    result
+  end
+
+  def deep_transform_keys!(&block)
+    keys.each do |key|
+      value = delete(key)
+      self[yield(key)] = value.is_a?(Hash) ? value.deep_transform_keys!(&block) : value
+    end
+    self
+  end
 end

data/lib/jeanine/core_ext/string.rb

@@ -3,4 +3,11 @@ class String
     return nil if self.empty?
     self
   end
+  def underscore
+    self.gsub(/::/, '/').
+        gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+        gsub(/([a-z\d])([A-Z])/,'\1_\2').
+        tr("-", "_").
+        downcase
+  end
 end

data/lib/jeanine/environment.rb

@@ -1,18 +1,16 @@
 module Broding
-  module Environment
-    def env
-      @_env ||= (ENV["RACK_ENV"].presence || "development")
-    end
+  def env
+    @_env ||= (ENV["RACK_ENV"].presence || "development")
+  end
 
-    def groups(*groups)
-      hash = groups.extract_options!
-      env = Jeanine.env
-      groups.unshift(:default, env)
-      groups.concat ENV["BRODY_GROUPS"].to_s.split(",")
-      groups.concat hash.map { |k, v| k if v.map(&:to_s).include?(env) }
-      groups.compact!
-      groups.uniq!
-      groups
-    end
+  def groups(*groups)
+    hash = groups.extract_options!
+    env = Jeanine.env
+    groups.unshift(:default, env)
+    groups.concat ENV["BRODY_GROUPS"].to_s.split(",")
+    groups.concat hash.map { |k, v| k if v.map(&:to_s).include?(env) }
+    groups.compact!
+    groups.uniq!
+    groups
   end
 end

data/lib/jeanine/generator/new/Gemfile.tt

@@ -0,0 +1,9 @@
+source 'https://rubygems.org'
+
+ruby "$RUBY_VERSION$"
+
+gem "jeanine"
+
+group :production do
+  gem "puma"
+end

data/lib/jeanine/generator/new/README.md.tt

@@ -0,0 +1,8 @@
+# README
+
+Welcome to your Jeanine app.
+
+## Start
+
+`$ bundle`
+`$ rackup`

data/lib/jeanine/generator/new/app.rb.tt

@@ -0,0 +1,10 @@
+require_relative 'boot'
+
+require 'jeanine'
+
+# Require the gems listed in Gemfile, including any gems
+# you've limited to :test, :development, or :production.
+Bundler.require(*Jeanine.groups)
+
+class App < ::Jeanine::App
+end

data/lib/jeanine/generator/new/config.ru.tt

@@ -0,0 +1,3 @@
+require_relative './app'
+
+run App

data/lib/jeanine/generator/new/config/boot.rb.tt

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+ENV['BUNDLE_GEMFILE'] ||= File.expand_path('../Gemfile', __dir__)
+
+require 'bundler/setup' # Set up gems listed in the Gemfile.

data/lib/jeanine/generator/new/config/environment.rb.tt

@@ -0,0 +1 @@
+require_relative '../app'

data/lib/jeanine/generator/new/config/puma.rb.tt

@@ -0,0 +1,35 @@
+# Puma can serve each request in a thread from an internal thread pool.
+# The `threads` method setting takes two numbers: a minimum and maximum.
+# Any libraries that use thread pools should be configured to match
+# the maximum value specified for Puma. Default is set to 5 threads for minimum
+# and maximum; this matches the default thread size of Active Record.
+#
+max_threads_count = ENV.fetch("RACK_MAX_THREADS") { 5 }
+min_threads_count = ENV.fetch("RACK_MIN_THREADS") { max_threads_count }
+threads min_threads_count, max_threads_count
+
+# Specifies the `port` that Puma will listen on to receive requests; default is 3000.
+#
+port        ENV.fetch("PORT") { 3000 }
+
+# Specifies the `environment` that Puma will run in.
+#
+environment ENV.fetch("RACK_ENV") { "development" }
+
+# Specifies the `pidfile` that Puma will use.
+pidfile ENV.fetch("PIDFILE") { "tmp/pids/server.pid" }
+
+# Specifies the number of `workers` to boot in clustered mode.
+# Workers are forked web server processes. If using threads and workers together
+# the concurrency of the application would be max `threads` * `workers`.
+# Workers do not work on JRuby or Windows (both of which do not support
+# processes).
+#
+# workers ENV.fetch("WEB_CONCURRENCY") { 2 }
+
+# Use the `preload_app!` method when specifying a `workers` number.
+# This directive tells Puma to first boot the application and load code
+# before forking the application. This takes advantage of Copy On Write
+# process behavior so workers use less memory.
+#
+# preload_app!

data/lib/jeanine/mimes.rb

@@ -1,11 +1,15 @@
-require 'rack'
-
 module Jeanine
   class Mimes
     MimeTypeNotFound = Class.new(StandardError)
     MIME_TYPES_INVERTED = ::Rack::Mime::MIME_TYPES.invert
 
+    def self.loaded?
+      @loaded
+    end
+
     def self.load!
+      return if loaded?
+      @loaded = true
       register(:json, Rack::Mime::MIME_TYPES[".json"])
       register(:html, Rack::Mime::MIME_TYPES[".html"])
       register(:text, Rack::Mime::MIME_TYPES[".text"])

data/lib/jeanine/{renderer.rb → rendering.rb}

@@ -1,6 +1,15 @@
 require 'jeanine/view'
+require 'jeanine/view_paths'
 
 module Jeanine
+  def self.view_paths
+    @_view_paths ||= Set.new(["views"])
+  end
+
+  def self.tilt_cache
+    @title_cache ||= Tilt::Cache.new
+  end
+
   class Renderer
     def self._renderers
       @_renderers ||= Set.new
@@ -139,4 +148,21 @@ module Jeanine
       text
     end
   end
+
+  module Rendering
+    def self.included(klass)
+      klass.extend ClassMethods
+    end
+
+    def render(*args)
+      @response.action_variables = instance_variables_cache
+      Renderer.new(@response).render(*args)
+    end
+
+    module ClassMethods
+      def append_view_path(path)
+        Jeanine.view_paths << path
+      end
+    end
+  end
 end

data/lib/jeanine/request.rb

@@ -1,5 +1,4 @@
 require 'rack/request'
-require 'jeanine/headers'
 
 module Jeanine
   class Request < Rack::Request
@@ -17,8 +16,8 @@ module Jeanine
       super
     end
 
-    def headers
-      @headers ||= Jeanine::Headers.new(self)
+    def params
+      super.deep_transform_keys!(&:to_sym)
     end
 
     def post?

data/lib/jeanine/rescuable.rb

@@ -0,0 +1,41 @@
+module Jeanine
+  module Rescuable
+    def self.included(base)
+      base.extend ClassMethods
+      base.prepend InstanceMethods
+    end
+
+    module InstanceMethods
+      def call(env)
+        begin
+          super
+        rescue => error
+          handler = self.class.rescue_handlers[error.class.to_s]
+          raise error unless handler
+          if handler.is_a?(Symbol)
+            @response.write(send(handler, error))
+          else
+            @response.write(instance_exec(error, &handler))
+          end
+          @response.complete!
+        end
+      end
+    end
+
+    module ClassMethods
+      def rescue_from(*exceptions, with: nil, &block)
+        exceptions.each do |exception|
+          if with
+            rescue_handlers[exception.to_s] = with
+          else
+            rescue_handlers[exception.to_s] = block
+          end
+        end
+      end
+
+      def rescue_handlers
+        @rescue_handlers ||= {}
+      end
+    end
+  end
+end

data/lib/jeanine/routing/evaluation.rb

@@ -2,18 +2,13 @@ module Jeanine
   module Routing
     module Evaluation
       def route_eval
-        before_find_route!
         route = find_route
-
         if route
-          before_evaluate_route!
           result = instance_eval(&route[:block])
           @response.write(result)
-          after_evaluate_route!
         else
           @response.status = 404
         end
-        after_response!
         @response.complete!
       end
 
@@ -42,54 +37,6 @@ module Jeanine
         route
       end
 
-      def before_find_route!
-        run_before_callbacks!(:before_all)
-      end
-
-      def before_evaluate_route!
-        run_before_callbacks!(:before)
-      end
-
-      def after_evaluate_route!
-        run_after_callbacks!(:after)
-      end
-
-      def after_response!
-        run_after_callbacks!(:after_all)
-      end
-
-      def run_before_callbacks!(type)
-        if type == :before_all
-          self.class._callbacks[type].each { |callback| eval_callback(&callback[:block]) }
-        else
-          matching_callbacks(type) do |callback|
-            eval_callback(&callback[:block])
-          end
-        end
-      end
-
-      def run_after_callbacks!(type)
-        if type == :after_all
-          self.class._callbacks[type].each { |callback| eval_callback(&callback[:block]) }
-        else
-          matching_callbacks(type) do |callback|
-            eval_callback(&callback[:block])
-          end
-        end
-      end
-
-      def matching_callbacks(type)
-        self.class._callbacks[type].select do |callback|
-          paths = callback[:paths]
-          if paths.detect { |path| path.match?(@request.path_info) }
-            yield callback
-          end
-        end
-      end
-
-      def eval_callback(*args, &callback)
-        instance_exec(*args, &callback)
-      end
     end
   end
 end

data/lib/jeanine/version.rb

@@ -1,3 +1,3 @@
 module Jeanine
-  VERSION = "0.4.0"
+  VERSION = "0.7.2"
 end

data/lib/jeanine/view_paths.rb

@@ -1,7 +1,8 @@
+require 'tilt'
+
 module Jeanine
+
   module ViewPaths
-    def append_view_path(path)
-      Jeanine.view_paths << path
-    end
+
   end
 end

metadata

@@ -1,12 +1,12 @@
 --- !ruby/object:Gem::Specification
 name: jeanine
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.7.2
 platform: ruby
 authors:
 - Josh Brody
 autorequire: 
-bindir: bin
+bindir: exe
 cert_chain: []
 date: 2020-07-08 00:00:00.000000000 Z
 dependencies:
@@ -94,28 +94,52 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-description: A framework.
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A lightning-fast, batteries-included Ruby web micro-framework.
 email:
 - git@josh.mn
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- README.md
+- exe/jeanine
 - lib/jeanine.rb
 - lib/jeanine/app.rb
 - lib/jeanine/callbacks.rb
+- lib/jeanine/cli.rb
 - lib/jeanine/core_ext.rb
 - lib/jeanine/core_ext/array.rb
 - lib/jeanine/core_ext/hash.rb
 - lib/jeanine/core_ext/nil_class.rb
 - lib/jeanine/core_ext/string.rb
 - lib/jeanine/environment.rb
+- lib/jeanine/generator/new/Gemfile.tt
+- lib/jeanine/generator/new/README.md.tt
+- lib/jeanine/generator/new/app.rb.tt
+- lib/jeanine/generator/new/config.ru.tt
+- lib/jeanine/generator/new/config/boot.rb.tt
+- lib/jeanine/generator/new/config/environment.rb.tt
+- lib/jeanine/generator/new/config/puma.rb.tt
 - lib/jeanine/headers.rb
 - lib/jeanine/mimes.rb
 - lib/jeanine/path_proxy.rb
-- lib/jeanine/renderer.rb
+- lib/jeanine/rendering.rb
 - lib/jeanine/request.rb
-- lib/jeanine/rescuing.rb
+- lib/jeanine/rescuable.rb
 - lib/jeanine/response.rb
 - lib/jeanine/router.rb
 - lib/jeanine/routing.rb
@@ -147,8 +171,9 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
+rubyforge_project: 
+rubygems_version: 2.6.14.3
 signing_key: 
 specification_version: 4
-summary: A framework.
+summary: A lightning-fast, batteries-included Ruby web micro-framework.
 test_files: []

data/lib/jeanine/rescuing.rb

@@ -1,17 +0,0 @@
-module Jeanine
-  module Rescuing
-    def rescue_from(*exceptions, with: nil, &block)
-      exceptions.each do |exception|
-        if with
-          rescue_handlers[exception] = with
-        else
-          rescue_handlers[exception] = block
-        end
-      end
-    end
-
-    def rescue_handlers
-      @rescue_handlers ||= {}
-    end
-  end
-end