contingency 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 21458e2b0634b9e68a901d2008418bbae490fdfe
-  data.tar.gz: c590972c7818e0f7c06dc2227fe72d3b78124f1c
+  metadata.gz: c9134c71586b5d7aac0b9727f60bb93c42bbc7dd
+  data.tar.gz: 4997bbb2c4aa49e210def0d56b05501b8ad9407d
 SHA512:
-  metadata.gz: b41aa57923b2beeb99aa025f72cf65b6805f26e071565649c6be14eb5e7c9806f82d570acce03d1fc411e1cbf0fb472f28b31e2c663d719cde0b6cc951018fe5
-  data.tar.gz: c3871c5eeb363b533472ec76c6c6d3eec1cd94b23afd650d0fb62fc00219e9602dc74aae6663e0a6436475ddd75e84278cb38cfd9e11e527e43335c3256a24cb
+  metadata.gz: ce5c44af5d7d25603f7e3ba1352f6feb1e83abefe3b5af02c0271c5aa3e19bda3e716689404758d91b4d305e18d6e2849321546b59a4bd8504837659771be7c4
+  data.tar.gz: f9ede3175ea4026ecb8614b85f79778f7428b381ded5c13d8990372b840e9b686ac9789b12a39c9989ce2b82bc0e538469dd549909dec7cfdca242c48e1540d5

data/README.md

@@ -6,15 +6,13 @@
 
 >   * *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.
+Contingency is the custom error page controller you've implemented in every project you've ever written. It's designed to be framework-agnostic and has [many integrations](#supported-integrations) to make using it as easy as calling a config block.
 
-So for the love of god, stop implementing it yourself.
+So why implement it yourself again?
 
 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.
+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.
 
 <a name='table-of-contents'>
 ## Table of Contents
@@ -24,10 +22,10 @@ Experience true freedom, and make yourself a Contingency Plan.
 * [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)
+* [Integrating Contingency Yourself](#integrating-contingency-yourself)
+    * [Integration API](#three-integration-methods)
+    * [Please Contribute](#please-contribute)
+* [Versioning](#versioning)s
     * [Contingency Versioning](#contingency-versioning)
     * [Integration Versioning](#contingency-integration-versioning)
 * [Contributing Integrations](#contributing-integrations)
@@ -40,12 +38,11 @@ Experience true freedom, and make yourself a Contingency Plan.
 ## Installation
 </a>
 
-Add these lines to your application's Gemfile:
+Add this line to your application's Gemfile:
 
-    gem 'contingency',                    '~> 1.0'
-    gem 'contingency_my-framework-name',  '~> x.0'
+    gem 'contingency-my_framework_name',  '~> x.0', require: 'contingency/adapters/my_framework_name'
 
-...where [my-framework-name](#supported-integrations) is the name of your framework.
+...where [`my_framework_name`](#supported-integrations) is the name of your framework, and `x` is the major version of the framework you're using.
 
 Then, execute:
 
@@ -64,22 +61,22 @@ Contingency
 <table>
   <thead>
     <tr>
-      <td>Contingency Plan</td>
+      <td>Integration</td>
       <td>Integration Quality</td>
-      <td>Version</td>
+      <td>Supported Versions</td>
       <td>Maintainer</td>
     </tr>
   </thead>
   <tbody>
     <tr>
       <td>
-        <a href='#rails-integration'>Rails</a>
+        <a href='https://www.github.com/christhekeele/contingency_rails'>Rails</a>
       </td>
       <td>
-        <a href='#poor-dependency-management'>Poor</a>
+        **Bad**
       </td>
       <td>
-        <a href='https://www.github.com/christhekeele/contingency_rails'>0.0.1</a>
+        <a href='https://rubygems.org/gems/contingency_rails'>3.x</a>
       </td>
       <td>
         <a href='https://www.github.com/christhekeele/contingency_rails/issues'>christhekeele</a>
@@ -88,30 +85,23 @@ Contingency
   </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.
+**Great** integrations have functional tests and good documentation, **good** integrations only have functional tests, **poor** integrations only have documentaion, and **bad** ones have neither.
 
 <a name='integrating-contingency-yourself'>
-### Integrating it 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:
+If the framework you're using doesn't have a Contingency integration, you're only 3 methods away from integrating it yourself.
 
 <a name='three-integration-methods'>
-#### Integration Dependencies
+### Integration API
 </a>
 
-<a name='for-the-love-of-god-contribute'>
+<a name='please-contribute'>
+### Please 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.
+If you decide to go through this trouble, you really should consider [contributing your Contingency integration](#contributing-integrations) to Contingency.</a>
 
 <a name='versioning'>
 ## Versioning
@@ -127,31 +117,7 @@ Contingency itself is versioned as it changes. It bumps its major version as its
 ### 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**.
+Contingency integrations should take their major version number from [their frameworks](#supported-integrations). The rest is up to the maintainer.
 
 <a name='contributing-integrations'>
 ## Contributing Integrations
@@ -162,14 +128,13 @@ See [contingency_rails](https://www.github.com/christhekeele/contingency_rails)
 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. Implement the 3 API 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.
+1. Revel in the fact that you've provided a Contingency plan for you and yours
+1. Follow [the steps below](#contributing-to-contingency) to update this README with links to your Contingency integrationaccepted
 
 
 <a name='contributing-to-contingency'>
@@ -178,13 +143,10 @@ See [contingency_rails](https://www.github.com/christhekeele/contingency_rails)
 
 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. Add the name of your integration to the integrations array in the contingency/integration.rb file if [you're contributing a Contingency integration](#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
@@ -194,11 +156,10 @@ See [contingency_rails](https://www.github.com/christhekeele/contingency_rails)
 ### Contributers
 </a>
 
-* None, aside from [the creator](https://www.github.com/christhekeele/contingency). [Be the first!](#contributing-to-contingency)!
+* None, aside from [the creator](https://www.github.com/christhekeele). [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/lib/contingency/adapters/interface.rb

@@ -3,44 +3,36 @@ 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.
-      #
+      class InterfaceNotImplementedError < NotImplementedError; end
 
       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'`)."
+          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 self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      def error_renderer(code)
+        raise InterfaceNotImplementedError,
+          "Override this `error_renderer` method" \
+          " with one that expects an error code," \
+          " and uses your framework's render syntax" \
+          " to render Contingency.configuration.error_template."
+      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`)"
+      def failure_renderer(code)
+        raise InterfaceNotImplementedError,
+          "Override this `failure_renderer` method" \
+          " with one that expects an error code," \
+          " and uses your framework's render syntax"
+          " to display `Contingency.configuration.failure_message`."
 
-        end
       end
 
     end

data/lib/contingency/plan.rb

@@ -1,16 +1,14 @@
 module Contingency
 
   module Plan
-    extend ActiveSupport::Concern
-    extend ActiveSupport::Rescuable
 
+    def self.included(base)
+      base.send(:include, Contingency.adapter)
+      base.extend ActiveSupport::Rescuable
 
-    included do
-      extend Contingency.adapter
-
-      if catch_errors?
+      if base.catch_errors?
         Contingency.configuration.errors.each do |code, exceptions|
-          rescue_from *exceptions, with: ->(exception){ render_error code, exception }
+          base.rescue_from *exceptions, with: ->(exception){ render_error code, exception }
         end
       end
     end

data/lib/contingency/version.rb

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

data/lib/contingency.rb

@@ -1,4 +1,3 @@
-require 'active_support/concern'
 require 'active_support/rescuable'
 require 'logger'
 require "contingency/exceptions"
@@ -7,18 +6,16 @@ require "contingency/adapters/interface"
 module Contingency
 
   class << self
-    alias :configure :initialize
     attr_accessor :configuration
     attr_accessor :adapter, :adapters
   end
 
-  self.adapters = []
+  self.adapters = Contingency::Adapters.constants.reject{ |a| a == :Interface }
 
   def self.configure
-    self.adapter ||= self.adapters.first || Adapters::Interface
-    self.configuration ||= Configuration.new
+    self.adapter ||= Contingency::Adapters.const_get self.adapters.first || Adapters::Interface
+    self.configuration ||= defined?(self.adapter::Configuration) ? self.adapter::Configuration.new : Configuration.new
 
-    yield(self.adapter.default_configuration) if self.adapter.respond_to?(:default_configuration)
     yield(configuration) if block_given?
 
     require "contingency/plan"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: contingency
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.0
 platform: ruby
 authors:
 - Christopher Keele