err_supply-orac 1.0.0

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    MzRkYzJlZWZkMWY3YTc5YmIzODE2YWYwMDZhODBlMDczMmZhNzY4YQ==
+  data.tar.gz: !binary |-
+    NWQzMTU2ZDhlZmM4ODdkNjM1MjVlMDUyMzdkZWVkZjZhN2UwNTBjMA==
+SHA512:
+  metadata.gz: !binary |-
+    ZjUwYWQ2MzU5NjUxZjY0ZjYyMzA2MzY2ZmIyYTM3NTI0MzRiOGQ4MDNiYTg2
+    YWVjYTQxM2NlNmI1MzE2ZmY3ZTBmZTJhNzAzODMwNmJkODU5ZWJmMTg5NTJm
+    ZGE0ZmRmYTc1ZmFjYTQ3OWE1Zjg5ZWZhOTcwZjg1ZTkxY2U3NmU=
+  data.tar.gz: !binary |-
+    ZmM1YjY1YTY5YTg2Mjg0MmQzYzdkNmJmNjY1NmQ0YmM5ZGZlODY1YTY1Y2Y2
+    ZjJiNzUxMzBlMDE4NGNhZjczN2QxODI3ZGU4MjBhZWNlNTRlNWYwOTgyNmNi
+    NWU4MDUzODcwNDdjYzEwOTYyYWUyYjZhOWIzZjk0MzIyYTQ4ODg=

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2011 Coroutine, LLC
+
+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,281 @@
+# err_supply
+
+Err Supply is a Rails view helper that produces simple, beautiful error messages.
+
+The helper unpacks and rekeys the standard Rails error hash to make applying error messages to your views dead simple. Even better, because the extension cures Rails' brain-damaged way of recording errors from nested resources/attributes,  it works with both simple and complex forms.
+
+
+## What Is This?
+
+Err Supply is designed to make the default Rails error reporting structure more useful for complex
+interfaces.  
+
+### HTML vs AJAX form submissions
+
+We started thinking about Err Supply when we worked on a project that required an AJAX form submission.
+
+For normal HTML submissions, we coded up a custom error handler in Rails to display the messages below the
+form input. To replicate this for the AJAX submission, we realized we would have to convert the error hash
+to JSON and then wire up a jQuery event handler to perform the same DOM manipulations Rails was performing
+internally.  Obviously, we weren't super excited about having code in two places and in two languages to
+provide the same business value.
+
+
+### Ambiguous error messages for nested attributes
+
+The problem was compounded a few months later when we worked on a different project that required an AJAX
+form submission for a nested form.
+
+Here, even the workaround is problematic. Because Rails reports errors on nested attributes ambiguously,
+there really wasn't any way to use a javascript workaround without first reconstituting the error hash
+itself.
+
+If you don't know what I mean by saying the error messages are ambiguous, here's an example. Say you have
+these models defined:
+
+    class Father < ActiveRecord::Base
+      attr_accessible :name
+      attr_accessible :age
+
+      has_many :sons
+
+      accepts_nested_attributes_for :sons, :allow_destroy => true
+
+      validates_presence_of :name, :age
+    end
+
+    class Son < ActiveRecord::Base
+      attr_accessible :name
+      attr_accessible :age
+
+      belongs_to :father
+
+      validates_presence_of :name, :age
+    end
+
+If you pull up the nested edit form for a father with two sons and delete one son's name and the other
+son's age, Rails will return the following error hash:
+
+    {
+      "sons.name": ["can't be blank"],
+      "sons.age": ["can't be blank"]
+    }
+
+Umm, thanks, but which son is missing a name and which one is missing an age? Or is it the same son missing
+both values? Or, do they both have problems?
+
+
+
+## Our Solution
+
+Err Supply converts the Rails error hash from a slightly ambiguous object graph to a flat, unambiguous
+hash of DOM element ids. It does this by traversing the object graph for you and determining exactly which
+child resources have errors. It then adds those errors to a new hash object where the key is the DOM id
+of the corresponding form input.
+
+Err Supply publishes this newly constituted error hash via a custom jQuery event, allowing the view
+to handle errors through a single javascript interface.  This strategy allows errors from HTML and AJAX
+form submissions to be run through a single piece of code.
+
+
+
+## Installation
+
+Install me from RubyGems.org by adding a gem dependency to your Gemfile.  Bundler does
+the rest.
+
+	gem 'err_supply'
+
+Add the appropriate javascript file to the asset pipeline.  Err Supply comes with an adapter for
+Twitter Bootstrap enabled sites.  Those using other frameworks will need to write a separate adapter
+based on their framework's interface.
+
+	#= require err_supply-bootstrap
+
+
+Add the appropriate stylesheet file to the asset pipeline.  Err Supply comes with style classes for
+Twitter Bootstrap enabled sites.  Those using other frameworks will need to write a separate set of
+style classes based on their framework's interface.
+
+  @import 'err_supply-bootstrap';
+
+  
+
+## Basic Usage
+
+The main `err_supply` helper returns an escaped javascript invocation that triggers a custom
+event named `err_supply:loaded` and supplies the edited error hash as data.
+
+    <script type="text/javascript">
+      <%= err_supply @father %>
+    </script>
+
+This will evaluate @father.errors and apply an errors to the form. It assumes all form inputs
+are named in the standard rails way and that all error attribute keys match the form input
+keys exactly.
+
+
+### 1. Whitelists/Blacklists
+
+Attributes can be whitelisted or blacklisted using the standard `:only` and `:except` notation.
+
+Because `err_supply` will ignore any unmatched attributes, such declarations are not strictly
+required.  They typically only make sense for minor actions against models with many,
+many attributes.
+
+
+### 2. Changing Labels
+
+Say a User class has an attribute `:born_on` to store the user's date of birth.  In your form
+builder you declare the textbox normally like so:
+
+    <%= f.text_field :born_on %>
+
+A presence\_of error will be formatted as:
+
+    Born on can't be blank.
+
+To make this nicer, we can change the label for the attribute like this:
+
+    <script type="text/javascript">
+      <%= err_supply @user, :born_on => { :label => "Date of birth" } %>
+    </script>
+
+This will attach the following presence of error to the :born_on field:
+
+    Date of birth can't be blank.
+
+
+### 3. Changing Keys
+
+Say a User class belongs to an Organization class.  In your form, you declare a selector
+for assigning the organization.  The selector is named `:ogranization_id`.
+
+Depending on how your validations are written, you might very well get an error message for
+this form keyed to `:organization`.  Because your selector is keyed to `:organization_id`,
+the default javascript handler will consider this an unmatched attribute.
+
+You can solve this problem by changing the key for the attribute like so:
+
+    <script type="text/javascript">
+      <%= err_supply @user, :organization => { :key => :organization_id } %>
+    </script>
+
+
+### 4. Nested Attributes
+
+You can apply the same principles to nested attributes by nesting the instructions. To return
+to our father/son example, you can change the name labels for both entities using the following
+notation:
+
+    <script type="text/javascript">
+      <%= err_supply  @father,
+                      :name => { :label => "Father's name" },
+                      :sons => {
+                        :name => { :label => "Son's name" }
+                      }
+      %>
+    </script>
+
+
+### 5. Combining Instructions (aka Go Crazy)
+
+Attribute instructions are provided as hashes so that both `key` and `label` changes can be
+declared on the same attribute.
+
+Honestly, such instructions are rare in the real world, but error handling can get weird fast,
+so the library supports it.  
+
+
+
+
+## Advanced Usage
+
+There are a handful of scenarios that fall outside the area of basic usage worth discussing.
+
+### 1. AJAX Submissions and Nested Forms
+
+When Rails submits a nested form via a full page refresh, Rails automatically re-indexes any
+DOM elements in a nested collection starting at 0.
+
+If you're submitting a form remotely, it's on you to do this by re-rendering the nested fields
+with the current collection.
+
+As long as you do this before the `err_supply` call is made, everything will work normally.
+
+
+### 2. Other Javascript Libraries
+
+If you don't use jQuery, you may want to override the `err_supply` helper to format the
+javascript invocation differently.
+
+The library is constructed so the main public method named `err_supply` is pretty dumb. Most
+of the real hash-altering magic occurs in a protected method called `err_supply_hash`. You can
+override the much simpler method without worrying about damaging the core hash interpretation
+functionality.
+
+See the `lib` directory for details.
+
+
+### 3. Handling Unmatched Errors
+
+The default javascript handler bundles up unmatched error keys into a new hash and publishes them
+using the custom jQuery event `err_supply:unmatched`.
+
+
+
+
+## Prerequisites
+
+* <b>Ruby on Rails:</b> <http://rubyonrails.org>
+* <b>jQuery:</b>        <http://jquery.com>
+
+
+
+
+## Helpful Links
+
+* <b>Repository:</b>  <http://github.com/coroutine/err_supply>
+* <b>Gem:</b>         <http://rubygems.org/gems/err_supply>
+* <b>Authors:</b>     <http://coroutine.com>
+
+
+
+
+## Gemroll
+
+Other gems by Coroutine include:
+
+* [acts\_as\_current](http://github.com/coroutine/acts_as_current)
+* [acts\_as\_label](http://github.com/coroutine/acts_as_label)
+* [acts\_as\_list\_with\_sti\_support](http://github.com/coroutine/acts_as_list_with_sti_support)
+* [delayed\_form\_observer](http://github.com/coroutine/delayed_form_observer)
+* [kenny\_dialoggins](http://github.com/coroutine/kenny_dialoggins)
+* [michael\_hintbuble](http://github.com/coroutine/michael_hintbuble)
+* [tiny\_navigation](http://github.com/coroutine/tiny_navigation)
+
+
+
+
+## License
+
+Copyright (c) 2011 [Coroutine LLC](http://coroutine.com).
+
+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/Rakefile

@@ -0,0 +1,2 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks

data/err_supply.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'err_supply/version'
+
+Gem::Specification.new do |spec|
+  spec.name        = 'err_supply-orac'
+  spec.version     = ErrSupply::VERSION
+  spec.authors     = ['Coroutine', 'John Dugan']
+  spec.email       = ['gems@coroutine.com']
+  spec.summary     = %q{Simple, beautiful error messages for Rails.}
+  spec.description = %q{Simple, beautiful error messages for Rails. Err_supply unpacks and rekeys the standard Rails error hash to make applying error messages to your views dead simple. Even better, because the library cures Rails' brain-damaged way of recording errors from nested resources/attributes, err_supply works with both simple and complex forms.}
+  spec.homepage    = 'http://github.com/coroutine/err_supply'
+  spec.licenses    = ['MIT']
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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 'rails', '>= 3.0.0'
+
+  spec.add_development_dependency 'rspec', '>= 2.0.0'
+end

data/lib/assets/javascripts/err_supply-bootstrap.js

@@ -0,0 +1,94 @@
+/*
+ErrSupply Twitter Bootstrap3 Adapter
+Copyright (c) 2014  Coroutine LLC
+Licensed under the MIT license
+*/
+(function() {
+  var errSupplyPlugin = function(event, errors) {
+		
+		// define how errors are applied to dom elements
+		var applyFn	 = function(error_hash) {
+			var unmatched = {};
+			var errors    = error_hash || {};
+			var error;
+			var content;
+			var $field;
+			var position;
+			
+			for (var id in errors) {
+				error = errors[id];
+				if (error && error.messages && error.messages.length) {
+					
+					content = '<ul class="err_supply">';
+					for (var i = 0, n = error.messages.length; i < n; i++) {
+						content += '<li>' + error.label + " " + error.messages[i] + '</li>';
+					};
+					content += '</ul>';
+				
+					$field  = $('#' + id);
+          options = {}
+					if ($field.offset()) {
+					
+						// determine position
+						if (($field.offset().left + $field.outerWidth() + 300) < $(window).width()) {
+							position = 'right';
+						}
+						else {
+							position = 'left';
+						};
+					
+						// add class 
+						$field.addClass('error').closest('.input-group').addClass('has-error');
+					
+						// add popover
+            $field.popover({
+              html: true,
+              placement: position,
+              trigger: 'focus',
+              content: content
+            });
+					}
+					else {
+						unmatched[id] = error;
+					};
+				};
+			};
+			
+			return unmatched;			
+		};
+		
+		// get reference to form firing event
+		var $form = $(this);
+		
+		// find all contained elements with a style of error and remove the class.
+		// this is typically more important for ajax submissions. html submissions
+		// tend not to have this problem.
+		$form.find('.error').removeClass('error').closest('.input-group').removeClass('has-error');
+		
+		// hide all fields that have been explicitly destroyed. when an html submission
+		// has errors, the _destroy value renders as true rather than 1, which may or may not
+		// causes destroyed sets to be visible after the reload.  here, we scan for both 
+		// values and hide any containing div.fields elements.
+		$form.find('input:hidden[id$=_destroy]').filter('[value=true], [value=1]').closest('.fields').hide();
+		
+		// apply errors to dom elements
+		var unmatched_errors = applyFn(errors) || {};
+		
+		// publish unmatched errors, in case view cares about that
+		$form.trigger('err_supply:unmatched', unmatched_errors);
+		
+		// move focus to first field with error (or first field)
+		var $focus_field = ($form.find('.error').size() > 0) ?
+													$form.find('.error').filter(':first') :
+													$form.find(':not(.filter) :input:visible:enabled:first');
+		$focus_field.focus()
+	};
+
+  $.fn.err_supply = function() {
+    $(this).on("err_supply:loaded", errSupplyPlugin.bind(this));
+  }
+})()
+
+jQuery(function($) {
+  $("form").err_supply();
+});

data/lib/assets/stylesheets/err_supply-bootstrap.scss

@@ -0,0 +1,21 @@
+/*---------------------------------------------
+  err_supply styles
+-----------------------------------------------*/
+
+ul.err_supply {
+  margin: 0;
+  padding: 0;
+  list-style: none;
+}
+
+.form-group .popover {
+  width: 325px;
+  background: $brand-danger;
+  color: #fff;
+}
+.form-group .popover.right .arrow:after {
+  border-right-color: $brand-danger;
+}
+.form-group .popover.left .arrow:after {
+  border-left-color: $brand-danger;
+}

data/lib/err_supply.rb

@@ -0,0 +1,26 @@
+require 'err_supply/version'
+require 'err_supply/controller_helpers'
+require 'err_supply/view_helpers'
+
+module ErrSupply
+  class Engine < ::Rails::Engine
+    
+    #-------------------------------------------------------
+    # Initialization
+    #-------------------------------------------------------
+    initializer "err_supply.start" do |app|
+      
+      # extend views
+      ActiveSupport.on_load :action_view do 
+        include ErrSupply::ViewHelpers
+      end
+      
+      # extend controllers
+      ActiveSupport.on_load :action_controller do
+        include ErrSupply::ControllerHelpers
+      end
+      
+    end
+    
+  end
+end

data/lib/err_supply/controller_helpers.rb

@@ -0,0 +1,90 @@
+module ErrSupply
+  module ControllerHelpers
+    
+    # Declare our method as a helper method so it is accessible to views.
+    ActionController::Base.helper_method :err_supply_hash
+    
+    # This method can be called recursively to unpack a rails object's error hash 
+    # into something more manageable for the view. Basically, it uses the keys in the
+    # object's error hash to traverse the object graph and expand the errors into a
+    # flattened hash, keyed using the dom ids rails will generate for the 
+    # associated objects.
+    #
+    # Because the method is called recursively, it only pays attention to errors for 
+    # the given object and its immediate child collections.  More remote descendents
+    # will be processed in subsequent passes.
+    #
+    def err_supply_hash(obj, options={})
+
+      #---------------------------------------------
+      # set up main variables
+      #---------------------------------------------
+
+      prefix  = options[:prefix]
+      errors  = obj.errors
+      h       = {}
+
+
+      #---------------------------------------------
+      # apply options to local attrs
+      #---------------------------------------------
+
+      # get keys
+      attrs   = errors.keys.select { |k| k.to_s.split(".").size == 1 }
+
+      # whitelist/blacklist keys
+      if options.has_key?(:only)
+        attrs = attrs.select { |k| Array(options[:only]).flatten.include?(k) }
+      end
+      if options.has_key?(:except)
+        attrs = attrs.reject { |k| Array(options[:except]).flatten.include?(k) }
+      end
+
+      # apply errors that match our list (slightly inefficient, but a touch easier to read)
+      attrs.each do |attr|
+        o  = options[attr.to_sym] || {}
+        id = [prefix, "#{(o[:key] || attr).to_s}"].reject(&:blank?).join('_')
+
+        unless h.has_key?(id)
+          h[id] = {
+            "label"    => obj.class.human_attribute_name(attr),
+            "messages" => []
+          }
+        end
+
+        h[id]["label"]    = o[:label].to_s.underscore.humanize unless o[:label].nil?
+        h[id]["messages"] = (h[id]["messages"] + errors[attr].map { |msg| "#{msg}.".gsub("..", ".") }).flatten
+      end
+
+
+      #---------------------------------------------
+      # apply options to children
+      #---------------------------------------------
+  
+      # get keys
+      assoc_names = errors.keys.map { |k| k.to_s.split(".") }.select { |a| a.many? }.map { |a| a[0] }.compact.uniq
+
+      # if child has errors or is invalid (i.e., we prefer explicitly declared errrors),
+      # call function recursively and merge results
+      assoc_names.each do |assoc_name|
+        c_options = options[assoc_name.to_sym] || {}
+        obj.send("#{assoc_name}").each_with_index do |child, index|
+          if !child.errors.empty? or child.invalid?
+            c_prefix = [prefix, "#{assoc_name}_attributes_#{index}"].reject(&:blank?).join('_')
+            c_hash   = err_supply_hash(child, c_options.merge({ :prefix => c_prefix }))
+
+            h.merge!(c_hash)
+          end
+        end
+      end
+
+
+      #---------------------------------------------
+      # return the hash
+      #---------------------------------------------
+      h    
+
+    end
+    
+  end
+end

data/lib/err_supply/version.rb

@@ -0,0 +1,3 @@
+module ErrSupply
+  VERSION = '1.0.0'
+end

data/lib/err_supply/view_helpers.rb

@@ -0,0 +1,22 @@
+module ErrSupply
+  module ViewHelpers
+
+    # Converts the given object's error hash into our JSON structure and
+    # triggers a custom event on the associated form element.
+    #
+    def err_supply(obj, options={})
+      form_css_selector = options[:form_css_selector]
+
+      if form_css_selector.blank?
+        id = obj.new_record? ? dom_id(obj) : dom_id(obj, :edit)
+        form_css_selector = "##{id}"
+      end
+
+      prefix  = obj.class.name.underscore.split('/').last
+      payload = err_supply_hash(obj, options.merge({ :prefix => prefix }))
+
+      "$('#{ form_css_selector }').trigger('err_supply:loaded', #{ payload.to_json });".html_safe
+    end
+
+  end
+end

metadata

@@ -0,0 +1,89 @@
+--- !ruby/object:Gem::Specification
+name: err_supply-orac
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Coroutine
+- John Dugan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-02-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  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: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.0.0
+description: Simple, beautiful error messages for Rails. Err_supply unpacks and rekeys
+  the standard Rails error hash to make applying error messages to your views dead
+  simple. Even better, because the library cures Rails' brain-damaged way of recording
+  errors from nested resources/attributes, err_supply works with both simple and complex
+  forms.
+email:
+- gems@coroutine.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- err_supply.gemspec
+- lib/assets/javascripts/err_supply-bootstrap.js
+- lib/assets/stylesheets/err_supply-bootstrap.scss
+- lib/err_supply.rb
+- lib/err_supply/controller_helpers.rb
+- lib/err_supply/version.rb
+- lib/err_supply/view_helpers.rb
+homepage: http://github.com/coroutine/err_supply
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Simple, beautiful error messages for Rails.
+test_files: []