contingency 0.1.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 21458e2b0634b9e68a901d2008418bbae490fdfe
+  data.tar.gz: c590972c7818e0f7c06dc2227fe72d3b78124f1c
+SHA512:
+  metadata.gz: b41aa57923b2beeb99aa025f72cf65b6805f26e071565649c6be14eb5e7c9806f82d570acce03d1fc411e1cbf0fb472f28b31e2c663d719cde0b6cc951018fe5
+  data.tar.gz: c3871c5eeb363b533472ec76c6c6d3eec1cd94b23afd650d0fb62fc00219e9602dc74aae6663e0a6436475ddd75e84278cb38cfd9e11e527e43335c3256a24cb

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in contingency.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Christopher Keele
+
+MIT License
+
+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,204 @@
+<a name='contingency'>
+# Contingency
+</a>
+
+> "Freedom is the recognition of contingency."
+
+>   * *Richard M. Rorty*
+
+Contingency is the custom error page controller you've implemented in every project you've ever written. It's compatibile with every framework you've ever implemented a project in. A [Contingency Plan](#supported-integrations) has been written for every Ruby framework you're familiar with. And odds are, its better tested than your implementation.
+
+So for the love of god, stop implementing it yourself.
+
+It's quick to get started, gives you full customization over Exception coverage, gives you full control over rendering your own error page, and has a contingency plan itself in the event that your custom error views trigger an Exception.
+
+It's also very lightweight: the core functionality (the module in `contingency/plan.rb`) is less than 50 lines; and only adds 3 integration methods, 2 helper methods, and 1 controller action method to your controller. Everything but the controller method is private. The rest of the codebase else is just a matter of integration. It's a hard codebase to get lost in.
+
+Experience true freedom, and make yourself a Contingency Plan.
+
+<a name='table-of-contents'>
+## Table of Contents
+</a>
+
+* [Installation](#installation)
+* [Configuration](#configuration)
+* [Supported Integrations](#supported-integrations)
+    * [Rails](#rails-integration)
+* [Custom Integrations](#custom-integrations)
+    * [Integrating Contingency Yourself](#integrating-contingency-yourself)
+        * [Integration Dependencies](#three-integration-methods)
+* [Versioning](#versioning)
+    * [Contingency Versioning](#contingency-versioning)
+    * [Integration Versioning](#contingency-integration-versioning)
+* [Contributing Integrations](#contributing-integrations)
+* [Contributing to Contingency](#contributing-to-contingency)
+* [Credits](#credits)
+    * [Contributers](#contributers)
+    * [Shout-Outs](#shout-outs)
+
+<a name='installation'>
+## Installation
+</a>
+
+Add these lines to your application's Gemfile:
+
+    gem 'contingency',                    '~> 1.0'
+    gem 'contingency_my-framework-name',  '~> x.0'
+
+...where [my-framework-name](#supported-integrations) is the name of your framework.
+
+Then, execute:
+
+    $ bundle
+
+<a name='configuration'>
+## Configuration
+</a>
+
+Contingency
+
+<a name='supported-integrations'>
+## Supported Integrations
+</a>
+
+<table>
+  <thead>
+    <tr>
+      <td>Contingency Plan</td>
+      <td>Integration Quality</td>
+      <td>Version</td>
+      <td>Maintainer</td>
+    </tr>
+  </thead>
+  <tbody>
+    <tr>
+      <td>
+        <a href='#rails-integration'>Rails</a>
+      </td>
+      <td>
+        <a href='#poor-dependency-management'>Poor</a>
+      </td>
+      <td>
+        <a href='https://www.github.com/christhekeele/contingency_rails'>0.0.1</a>
+      </td>
+      <td>
+        <a href='https://www.github.com/christhekeele/contingency_rails/issues'>christhekeele</a>
+      </td>
+    </tr>
+  </tbody>
+</table>
+
+<a name='rails-integration'>
+### Rails
+</a>
+
+<a name='custom-integrations'>
+## Custom Integrations
+</a>
+
+If the framework you're using doesn't have a Contingency Plan integration, you're only 3 methods away from integrating it yourself.
+
+<a name='integrating-contingency-yourself'>
+### Integrating it Yourself
+</a>
+
+It's easy to integrate Contingency into your own app. Contingency only relys on 3 methods to communicate with your framework:
+
+<a name='three-integration-methods'>
+#### Integration Dependencies
+</a>
+
+<a name='for-the-love-of-god-contribute'>
+</a>
+
+If you decide to go through this trouble, you really should consider [contributing your Contingency Plan integration](#contributing-integrations) to Contingency.</a> I'll be more than happy to help you develop your integration until [it meets our minimum quality standards](#versioning), if it doesn't out-of-the-box.
+
+<a name='versioning'>
+## Versioning
+</a>
+
+<a name='contingency-versioning'>
+### Contingency Versioning
+</a>
+
+Contingency itself is versioned as it changes. It bumps its major version as its API changes, which is rarely, as its public API only requires [3 methods](#three-integration-methods). It uses [symantic versioning](http://http://semver.org/). This means you should safely be able to install it with [loose bundler dependencies](#installation).
+
+<a name='contingency-integration-versioning'>
+### Integration Versioning
+</a>
+
+<a name='great-dependency-management'>
+#### Great
+</a>
+
+Contingency Plans should be versioned [with their frameworks](#supported-integrations). Integrations that follow this simple requirement are labeled as [**great**](#supported-integrations).
+
+<a name='good-dependency-management'>
+#### Good
+</a>
+
+Contingency Plans that keep up with at least [the major version of their framework](http://http://semver.org/) will result in the integration being labeled as [**good**](#supported-integrations).
+
+<a name='poor-dependency-management'>
+#### Poor
+</a>
+
+Contingency Plans that fail to keep up with [the major version of their framework](http://http://semver.org/) will result in the integration being labeled as [**poor**](#supported-integrations).
+
+<a name='bad-dependency-management'>
+#### Bad
+</a>
+
+Contingency Plans that throw off the shackles of [symantic versioning](http://http://semver.org/) and don't follow it from the get-go, Pull Request, or fall very behind will result in the integration being labeled as [**bad**](#supported-integrations).
+
+I keep up with these frameworks through [the Bundle Scout](https://bundlescout.com). You should, too! **Checkest thineself lest thy wrekest thineself**.
+
+<a name='contributing-integrations'>
+## Contributing Integrations
+</a>
+
+See [contingency_rails](https://www.github.com/christhekeele/contingency_rails) as an example.
+
+1. Create a new gem named after your framework (`bundle gem contingency-my_integration`)
+1. Add Contingency as a dependency to your gemspec and bundle install
+1. Generate an integration template (`bundle exec rake contingency:generate:plan[my_integration]`)
+1. Implement the 3 methods that rake instructs you to
+1. Commit your changes (`git commit -am 'Created my_integration'`)
+1. Push (`git push origin master`)
+1. Follow [the steps below](#contributing-to-contingency) to add autoloading your Contingency Plan in Contingency core and wait get your Pull Request accepted
+1. Create the intital build of your gem (`gem build contingency-my_integration`)
+1. Release your gem (`gem push contingency-my_integration.gem`)
+1. Revel in the fact that you've provided a Contingency Plan for you and yours
+1. Continue to mantain your integration over time by [handling API changes and bumping the version number in accordance with the framework](#versioning), lest your integration be marked as deprecated.
+
+
+<a name='contributing-to-contingency'>
+## Contributing to Contingency
+</a>
+
+1. Fork it
+1. Create your feature branch (`git checkout -b my-new-feature`)
+1. Add the name of your integration to the integrations array in the contingency/integration.rb file if [you're contributing a Contingency Plan](#contributing-integrations)
+1. Commit your changes (`git commit -am 'Add some feature'`)
+1. Push to the branch (`git push origin my-new-feature`)
+1. Create new Pull Request
+1. I tell you to go back and write some tests if you haven't already
+1. I tell you to go back and update the README.md if you haven't already
+1. I accept your Pull Request
+
+<a name='credits'>
+## Credits
+</a>
+
+<a name='contributers'>
+### Contributers
+</a>
+
+* None, aside from [the creator](https://www.github.com/christhekeele/contingency). [Be the first!](#contributing-to-contingency)!
+
+<a name='shout-outs'>
+### Shout-Outs
+</a>
+
+* Thanks to [nathanl](https://github.com/nathanl) and his excellent authorization gem, [Authority](https://github.com/nathanl/authority), the structure of which inspired this one.
+* Thanks to [ryanb](https://github.com/ryanb), and his subscription-worthy [Railscasts](http://railscasts.com/), which have inspired us all. Especially us [Pro users](http://railscasts.com/pro).

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/contingency.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'contingency/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "contingency"
+  spec.version       = Contingency::VERSION
+  spec.authors       = ["Christopher Keele"]
+  spec.email         = ["dev@chriskeele.com"]
+  spec.description   = "A framework agnostic exception catcher and custom error page generator."
+  spec.summary       = "Handle your ruby web application's errors your way, with your own beautiful customized error pages. Framework agnostic with several integrations and i18n support."
+  # spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activesupport",  ">= 3.0.0"
+  spec.add_dependency "i18n",           ">= 0.6.0"
+  spec.add_dependency "rake",           ">= 0.8.1.10"
+
+  spec.add_development_dependency "bundler",  "~> 1.3"
+  spec.add_development_dependency "rspec",    "~> 2.13"
+end

data/lib/contingency.rb

@@ -0,0 +1,37 @@
+require 'active_support/concern'
+require 'active_support/rescuable'
+require 'logger'
+require "contingency/exceptions"
+require "contingency/adapters/interface"
+
+module Contingency
+
+  class << self
+    alias :configure :initialize
+    attr_accessor :configuration
+    attr_accessor :adapter, :adapters
+  end
+
+  self.adapters = []
+
+  def self.configure
+    self.adapter ||= self.adapters.first || Adapters::Interface
+    self.configuration ||= Configuration.new
+
+    yield(self.adapter.default_configuration) if self.adapter.respond_to?(:default_configuration)
+    yield(configuration) if block_given?
+
+    require "contingency/plan"
+
+    configuration
+  end
+
+  def self.logger
+    @logger ||= configuration.logger
+  end
+
+
+end
+
+require "contingency/configuration"
+require "contingency/version"

data/lib/contingency/adapters/interface.rb

@@ -0,0 +1,48 @@
+module Contingency
+
+  module Adapters
+    module Interface
+
+      extend ActiveSupport::Concern
+
+      included do
+        class InterfaceNotImplementedError < NotImplementedError; end
+      end
+
+      ###
+      # Required integration methods go here.
+      #  They're implemented here as no-ops that raise an error so
+      #  all subclasses have to define them.
+      #
+
+      module ClassMethods
+        def catch_errors?
+          raise InterfaceNotImplementedError, "Override this `catch_errors?` method" \
+                                              " with one that decides if your framework should activate" \
+                                              " Contingency or not (ie `ENV[RACK_ENV] !== 'development'`)."
+        end
+      end
+
+      module InstanceMethods
+        def error_renderer(code)
+          raise InterfaceNotImplementedError, "Override this `error_renderer` method" \
+                                              " with one that expects an error code, and uses your framework's" \
+                                              " render method to find your views for it." \
+                                              " (ie `render Contingency.configuration.error_template, status: code`," \
+                                              " or even just `render code`)"
+        end
+
+        def failure_renderer(code)
+          raise InterfaceNotImplementedError, "Override this `failure_renderer` method" \
+                                              " with one that expects an error code, and uses your framework's" \
+                                              " render method to display a simple text error page in the event" \
+                                              " your `#{self.class.name}#error_renderer?`'s render can't render" \
+                                              " your error template." \
+                                              " (ie `render status: code, text: Contingency.configuration.error_template`)"
+
+        end
+      end
+
+    end
+  end
+end

data/lib/contingency/configuration.rb

@@ -0,0 +1,23 @@
+module Contingency
+  class Configuration
+
+    attr_accessor :errors, :error_messages,
+                  :error_layout, :error_template,
+                  :unknown_error_message, :failure_message,
+                  :logger
+
+    def initialize
+      @errors = {}
+      @error_messages = {}
+
+      @error_layout = ''
+      @error_template = ''
+
+      @unknown_error_message = ['Server Error', 'It looks like something went wrong.']
+      @failure_message =  "Server Error: It looks like something went wrong."
+
+      @logger = Logger.new(STDERR)
+    end
+
+  end
+end

data/lib/contingency/exceptions.rb

@@ -0,0 +1,21 @@
+module Contingency
+  module Exceptions
+    class ContingencyError < Exception
+      attr_accessor :message, :backtrace
+    end
+    class RenderedErrorPageException < ContingencyError
+      def initialize
+        @message = 'An error page was explicitly requested.'
+        @backtrace = ['None. No real error occured.']
+      end
+    end
+    class ContingencyPlanException < ContingencyError
+      def initialize(original_exception, handler_exception)
+        @message =  "`Contingency::Plan` encountered exception `#{handler_exception.class.name}`" \
+                    " while trying to handle exception `#{original_exception.class.name}`:" \
+                    "\n#{handler_exception.message}"
+        @backtrace = handler_exception.backtrace
+      end
+    end
+  end
+end

data/lib/contingency/plan.rb

@@ -0,0 +1,43 @@
+module Contingency
+
+  module Plan
+    extend ActiveSupport::Concern
+    extend ActiveSupport::Rescuable
+
+
+    included do
+      extend Contingency.adapter
+
+      if catch_errors?
+        Contingency.configuration.errors.each do |code, exceptions|
+          rescue_from *exceptions, with: ->(exception){ render_error code, exception }
+        end
+      end
+    end
+
+    def error
+      render_error(params[:code], Contingency::Exceptions::RenderedErrorPageException.new)
+    end
+
+    def error_report(exception)
+      "#{exception.class} raised on #{request.fullpath}:" \
+      "\n#{exception.message}" \
+      "\nBacktrace:" \
+      "\n#{exception.backtrace.join("\n")}"
+    end
+
+    def render_error(code, exception)
+      message, description = Contingency.configuration.error_messages.fetch(code, Contingency.configuration.unknown_error_message)
+      error_logger = logger.method(code.to_i < 500 ? :info : :error)
+      error_logger.call "#{code}: #{description}.\n" + error_report(exception)
+      @code = code
+      @message = message
+      @description = description
+      error_renderer(code)
+    rescue Exception => handler_exception
+      logger.fatal error_report(Contingency::Exceptions::ContingencyPlanException.new(exception, handler_exception))
+      failure_renderer(500)
+    end
+  end
+
+end

data/lib/contingency/version.rb

@@ -0,0 +1,3 @@
+module Contingency
+  VERSION = "0.1.3"
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: contingency
+version: !ruby/object:Gem::Version
+  version: 0.1.3
+platform: ruby
+authors:
+- Christopher Keele
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-04-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.1.10
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.1.10
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.13'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.13'
+description: A framework agnostic exception catcher and custom error page generator.
+email:
+- dev@chriskeele.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- contingency.gemspec
+- lib/contingency.rb
+- lib/contingency/adapters/interface.rb
+- lib/contingency/configuration.rb
+- lib/contingency/exceptions.rb
+- lib/contingency/plan.rb
+- lib/contingency/version.rb
+homepage: 
+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.0.0
+signing_key: 
+specification_version: 4
+summary: Handle your ruby web application's errors your way, with your own beautiful
+  customized error pages. Framework agnostic with several integrations and i18n support.
+test_files: []
+has_rdoc: