Removed the necessity to register an error before raising it

README.md

@@ -22,7 +22,9 @@ Or install it yourself as:
 
 ### Localizations
 
-Errawr uses [I18n](https://github.com/svenfuchs/i18n) for easily managing error localizations. Just define a locale using the ```errawr``` key.
+Errawr uses [I18n](https://github.com/svenfuchs/i18n) for easily managing error
+localizations. Just define an error in a locale file. Make sure to use the
+```errawr``` key.
 
 ```yaml
 en:
@@ -36,14 +38,6 @@ Need to add more locale files? Use I18n's standard ```load_path```.
 I18n.load_path += Dir.glob('lib/your_lib/locales/*.{rb,yml}')
 ```
 
-### Registering Errors
-
-Before you can raise an error you'll need to register it first.
-
-```ruby
-Errawr.register!(:your_error)
-```
-
 ### Raising Errors
 
 ```ruby
@@ -56,21 +50,10 @@ end
 
 ### Metadata
 
-It's possible to add additional information to a registered error through metadata. Just specify a ```metadata``` hash when either registering:
-
-```ruby
-Errawr.register!(:your_error, metadata: { http_status: 400 })
-begin
-  Errawr.error!(:your_error)
-rescue => e
-  puts e.metadata[:http_status] # Will return 400
-end
-```
-
-or throwing an error:
+It's possible to add additional information to a registered error through
+metadata. Just specify a ```metadata``` hash when throwing an error:
 
 ```ruby
-Errawr.register!(:your_error)
 begin
   Errawr.error!(:your_error, metadata: { http_status: 400 })
 rescue => e
@@ -91,10 +74,9 @@ en:
         http_status: 400
 ```
 
-Then just register and raise your exceptions like normal.
+Then just raise your exceptions like normal.
 
 ```ruby
-Errawr.register!(:your_error)
 begin
   Errawr.error!(:your_error)
 rescue => e
@@ -114,17 +96,17 @@ en
 ```
 
 ```ruby
-Errawr.register!(:your_error, error_message: 'You did it wrong!')
 begin
-  Errawr.error!(:your_error)
+  Errawr.error!(:your_error, error_message: 'You did it wrong!')
 rescue => e
   puts e.message # Will return "My awesome error message is: You did it wrong!"
 end
 ```
 
 ### Overrides
 
-Want to override that metadata you registered? That's cool too.
+It's possible to override metadata stored in a locale file both globally and
+on a per use basis.
 
 ```yaml
 en:
@@ -157,7 +139,7 @@ rescue => e
   puts e.message # => Will return "Yet another error message"
   puts e.metadata[:http_status] # => Will return 404
 end
-``` 
+```
 
 ### Custom Error Classes
 
@@ -194,4 +176,4 @@ end
 
 Errawr is maintained and funded by [Sticksnleaves](http://www.sticksnleaves.com)
 
-Thanks to all of our [contributors](https://github.com/anthonator/errawr/graphs/contributors)
+Thanks to all of our [contributors](https://github.com/anthonator/errawr/graphs/contributors)

lib/errawr.rb

@@ -7,24 +7,24 @@
 module Errawr
   I18n.load_path << "#{File.dirname(__FILE__)}/errawr/locales/en.yml"
   I18n.reload!
-  
+
   def self.included(base)
     base.extend(ClassMethods)
   end
-  
+
   module ClassMethods
     def error!(name, context = {})
-      klass = Mapper[name] || Mapper[:unknown]
+      klass = Mapper[name] || Error.new(name, context)
       klass.update_context(context) unless context.empty?
-      raise klass
+      fail klass
     end
 
     def register!(key, options = {})
       Mapper.register!(key, options)
     end
   end
-  
+
   extend ClassMethods
-  
+
   register!(:unknown)
 end

lib/errawr/error.rb

@@ -1,37 +1,38 @@
 module Errawr
   class Error < StandardError
     attr_reader :key, :context, :metadata
-    
+
     def initialize(key = :unknown, context = {})
       @key = key
-      @context = context
+      @context = context.dup
       @metadata = {}
       @i18n = I18n.t('errawr.' + @key.to_s)
       update_context(@context)
     end
-    
+
     def message
       process_message
     end
-    
+
     def update_context(context)
       process_context(context)
     end
-    
+
     private
+
     def process_context(context)
       @message_overridden = context.include?(:message)
-      if @i18n.kind_of?(Hash)
+      if @i18n.is_a?(Hash)
         @context.merge!(@i18n.merge(context))
       else
         @context.merge!(context)
       end
-      @metadata.merge!(@context.delete(:metadata)) if @context.has_key?(:metadata)
+      @metadata.merge!(@context.delete(:metadata)) if @context.key?(:metadata)
     end
-    
+
     def process_message
       return @context[:message] if @message_overridden
-      if @i18n.kind_of?(Hash)
+      if @i18n.is_a?(Hash)
         key = 'errawr.' + @key.to_s + '.message'
         @context[:message] = I18n.t(key, @context.merge({ default: I18n.t('errawr.unknown', @context) }))
       else
@@ -40,4 +41,4 @@ def process_message
       @context[:message]
     end
   end
-end
+end

spec/errawr_spec.rb

@@ -3,7 +3,6 @@
 describe Errawr do
   describe 'error!' do
     it 'should raise an Errawr::Error exception' do
-      Errawr.register!(:dummy_error)
       expect { Errawr.error!(:dummy_error) }.to raise_error(Errawr::Error)
     end
 
@@ -12,59 +11,57 @@
       begin
         Errawr.error!(:some_error)
       rescue => e
-        e.metadata[:name].should == 'custom_register!_name'
+        expect(e.metadata[:name]).to eq('custom_register!_name')
       end
     end
 
-    it 'should return custom metadata values using #error!' do
+    it 'should return custom metadata set with #register! using #error!' do
       Errawr.register!(:some_error, metadata: { name: 'custom_register!_name' })
       begin
         Errawr.error!(:some_error, metadata: { name: 'custom_error!_name' })
       rescue => e
-        e.metadata[:name].should == 'custom_error!_name'
+        expect(e.metadata[:name]).to eq('custom_error!_name')
       end
     end
 
     it 'should return custom metadata values from locale file' do
-      Errawr.register!(:error_hash)
       begin
         Errawr.error!(:error_hash)
       rescue => e
         expect(e.metadata).to include(:name)
       end
     end
 
-    it 'should override custom metadata values from #register! and locale file' do
+    it 'should override custom metadata values from #register! and locale file using #error!' do
       Errawr.register!(:error_hash, metadata: { name: 'register!_name' })
       begin
         Errawr.error!(:error_hash, metadata: { name: 'error!_name' })
       rescue => e
-        e.metadata[:name].should == 'error!_name'
+        expect(e.metadata[:name]).to eq('error!_name')
       end
     end
 
     it 'should return an overridden message for a non-hashed locale' do
       begin
         Errawr.error!(:some_error, message: 'Overridden error message')
       rescue => e
-        e.message.should == 'Overridden error message'
+        expect(e.message).to eq('Overridden error message')
       end
     end
 
     it 'should return an overridden message for a hashed locale' do
       begin
         Errawr.error!(:error_hash, message: 'Overridden error message')
       rescue => e
-        e.message.should == 'Overridden error message'
+        expect(e.message).to eq('Overridden error message')
       end
     end
 
     it 'should pass in interpolated params' do
-      Errawr.register!(:interpolated_error)
       begin
         Errawr.error!(:interpolated_error, error_message: 'interpolated message')
       rescue => e
-        e.message.should == 'Some error has occurred: interpolated message'
+        expect(e.message).to eq('Some error has occurred: interpolated message')
       end
     end
   end

spec/error_spec.rb

@@ -3,21 +3,21 @@
 describe Errawr::Error do
   it 'should return a key of :unknown if no key is set' do
     error = Errawr::Error.new
-    error.key.should == :unknown
+    expect(error.key).to eq(:unknown)
   end
-  
+
   it 'should return a localized message' do
     error = Errawr::Error.new(:some_error)
-    error.message.should == 'Some error has occurred'
+    expect(error.message).to eq('Some error has occurred')
   end
-  
+
   it 'should return a localized message if I18n value is a hash' do
     error = Errawr::Error.new(:error_hash)
-    error.message.should == 'Some hashed error has occurred'
+    expect(error.message).to eq('Some hashed error has occurred')
   end
-  
+
   it 'should return an unknown error if error => message is not provided' do
     error = Errawr::Error.new(:bad_error_hash)
-    error.message.should == 'An unknown error has occurred'
+    expect(error.message).to eq('An unknown error has occurred')
   end
-end
+end

spec/mapper_spec.rb

@@ -2,19 +2,19 @@
 
 describe Errawr::Mapper do
   it 'should automatically register an unknown error' do
-    Errawr::Mapper.all[:unknown].should_not be_nil
+    expect(Errawr::Mapper.all[:unknown]).to_not eq(nil)
   end
 
   describe '[]' do
     it 'should return stored errors' do
-      Errawr::Mapper[:unknown].should_not be_nil
+      expect(Errawr::Mapper[:unknown]).to_not eq(nil)
     end
   end
 
   describe 'add' do
     it 'should add an error to stored errors' do
       Errawr::Mapper.add(DummyError.new)
-      Errawr::Mapper[:dummy_key].should_not be_nil
+      expect(Errawr::Mapper[:dummy_key]).to_not eq(nil)
     end
   end
 
@@ -25,51 +25,46 @@
 
     it 'should add an error to stored errors' do
       Errawr.register!(:dummy_error)
-      Errawr::Mapper[:dummy_error].should_not be_nil
+      expect(Errawr::Mapper[:dummy_error]).to_not be_nil
     end
 
     it 'should not add :metadata options to context' do
-      Errawr.register!(:dummy_error, metadata: { name: :same_dummy_error })
       begin
-        Errawr.error!(:dummy_error)
+        Errawr.error!(:dummy_error, metadata: { name: :same_dummy_error })
       rescue => e
         expect(e.metadata).to_not include(:error)
       end
     end
 
     it 'should return an overridden message for a non-hashed locale' do
-      Errawr.register!(:some_error, message: 'Overridden error message')
       begin
-        Errawr.error!(:some_error)
+        Errawr.error!(:some_error, message: 'Overridden error message')
       rescue => e
-        e.message.should == 'Overridden error message'
+        expect(e.message).to eq('Overridden error message')
       end
     end
 
     it 'should return an overridden message for a hashed locale' do
-      Errawr.register!(:error_hash, message: 'Overridden error message')
       begin
-        Errawr.error!(:error_hash)
+        Errawr.error!(:error_hash, message: 'Overridden error message')
       rescue => e
-        e.message.should == 'Overridden error message'
+        expect(e.message).to eq('Overridden error message')
       end
     end
 
     it 'should override custom metadata values from locale file' do
-      Errawr.register!(:error_hash, metadata: { name: 'register!_name' })
       begin
-        Errawr.error!(:error_hash)
+        Errawr.error!(:error_hash, metadata: { name: 'register!_name' })
       rescue => e
-        e.metadata[:name].should == 'register!_name'
+        expect(e.metadata[:name]).to eq('register!_name')
       end
     end
 
     it 'should interpolate locales' do
-      Errawr.register!(:interpolated_error, error_message: 'interpolated message')
       begin
-        Errawr.error!(:interpolated_error)
+        Errawr.error!(:interpolated_error, error_message: 'interpolated message')
       rescue => e
-        e.message.should == 'Some error has occurred: interpolated message'
+        expect(e.message).to eq('Some error has occurred: interpolated message')
       end
     end
   end