errawr 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3f191ece7e68880cb8fe7c0f1b7602b93ec7682b
-  data.tar.gz: af5f3f544c7424e14b3a82b15b5767937b55208d
+  metadata.gz: a3b043ffb1dcda46e9beb5498e5978b54adf09fc
+  data.tar.gz: c5528e95eb0ce52255fb7f92a77f48efac869686
 SHA512:
-  metadata.gz: e13c00a643cf2b978bb901fcac57b8f9a5c49d55ce25519d445b347c1214c8e472e06fae443a53000c9f4b6d88c960e304912f4f70f7114501dd0c5631a8a3ea
-  data.tar.gz: 2d963cad145fd66659e42f929021277cb20e7f25dc6919985ec22ec011cb40c3bbf0b25635fe46ec458f29594661bc5b8420bf761e01c4b5d913269f1f174dd6
+  metadata.gz: a1fa4e75ee111570f0de9ab27778823c0e1c5e746c5c7b765819d6341f025c863d5b0715be5f01bb7ca8fdee0908161c420fa8a49e18841c2eb593c0e1d940b3
+  data.tar.gz: 1cb2fe1943cc8ec4d792fe5047a06bbc5cb91e735a7441d661710098c3b7cc43ab38361f1c0420709de97015cc68350c166d7f2d097ec1eecb0e2fad96efe2a7

data/README.md

@@ -44,24 +44,37 @@ Before you can raise an error you'll need to register it first.
 Errawr.register!(:your_error)
 ```
 
-It's also possible to pass in additional metadata when registering an error.
+### Raising Errors
 
 ```ruby
-Errawr.register!(:bad_request, { http_status: 400 })
 begin
-  Errawr.error!(:bad_request)
+  Errawr.error!(:your_error)
 rescue => e
-  puts e.context[:http_status]
+  puts e.message # Localized error message defined in locale file
 end
 ```
 
-### Raising Errors
+### 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.message # Localized error message defined in locale file
+  puts e.metadata[:http_status] # Will return 400
+end
+```
+
+or throwing an error:
+
+```ruby
+Errawr.register!(:your_error)
+begin
+  Errawr.error!(:your_error, metadata: { http_status: 400 })
+rescue => e
+  puts e.metadata[:http_status] # Will return 400
 end
 ```
 
@@ -73,9 +86,9 @@ It's also possible to manage your errors and their metadata purely through local
 en:
   errawr:
     your_error:
-      name: my error
-      error:
-        message: My awesome error message
+      message: My awesome error message
+      metadata:
+        http_status: 400
 ```
 
 Then just register and raise your exceptions like normal.
@@ -85,11 +98,29 @@ Errawr.register!(:your_error)
 begin
   Errawr.error!(:your_error)
 rescue => e
-  puts e.context[:name] # Will return "my error"
+  puts e.metadata[:http_status] # Will return 400
 end
 ```
 
-**Note** the ```errawr.your_error.error.message``` locale key. This is the key used to define an error message when managing an error through a locale file.
+### I18n Interpolation
+
+You can pass in parameter values to your localized error messages.
+
+```yaml
+en
+  errawr:
+  your_error:
+    message: "My awesome error message is: %{error_message}"
+```
+
+```ruby
+Errawr.register!(:your_error, error_message: 'You did it wrong!')
+begin
+  Errawr.error!(:your_error)
+rescue => e
+  puts e.message # Will return "My awesome error message is: You did it wrong!"
+end
+```
 
 ### Overrides
 
@@ -99,25 +130,32 @@ Want to override that metadata you registered? That's cool too.
 en:
   errawr:
     your_error:
-      name: my error
-      error:
-        message: My awesome error message
+      message: My awesome error message
+      metadata:
+        http_status: 400
 ```
 
+The ```#register!``` method will override the locale file.
+
 ```ruby
-# #register! overrides metadata defined in the locale file
-Errawr.register!(:your_error, name: 'my infamous error')
+Errawr.register!(:your_error, message: 'Some other error message', metadata: { http_status: 403 })
 begin
   Errawr.error!(:your_error)
 rescue => e
-  puts e.context[:name] # Will return "my infamous error"
+  puts e.message # => Will return "Some other error message"
+  puts e.metadata[:http_status] # => Will return 403
 end
+```
+
+The ```#error!``` method will override both ```#register!``` and the locale file.
 
+```ruby
+Errawr.register!(:your_error, message: 'Some other error message', metadata: { http_status: 403 })
 begin
-  # #error! metadata overrides both #register! and the locale file
-  Errawr.error!(:your_error, name: 'my very favorite error')
+  Errawr.error!(:your_error, message: 'Yet another error message', metadata: { http_status: 404 })
 rescue => e
-  puts e.context[:name] # Will return "my very favorite error"
+  puts e.message # => Will return "Yet another error message"
+  puts e.metadata[:http_status] # => Will return 404
 end
 ``` 
 
@@ -133,7 +171,7 @@ class YourError < Errawr::Error
 end
 
 # Register your error with your custom class
-Errawr.register!(:your_error, { error: { base_class: YourError } })
+Errawr.register!(:your_error, base_class: YourError)
 
 # Do something with it
 begin

data/lib/errawr/error.rb

@@ -1,11 +1,12 @@
 module Errawr
   class Error < StandardError
-    attr_reader :key, :context, :message
+    attr_reader :key, :context, :metadata, :message
     
     def initialize(key = :unknown, context = {})
       @key = key
       @i18n = I18n.t('errawr.' + @key.to_s)
       process_context(context)
+      process_metadata(context)
       process_message
     end
     
@@ -13,16 +14,23 @@ module Errawr
     def process_context(context)
       if @i18n.kind_of?(Hash)
         @context = @i18n.merge(context)
-        @context.delete(:error)
+        @context.delete(:metadata)
       else
         @context = {}
       end
     end
     
+    def process_metadata(context)
+      if @i18n.kind_of?(Hash)
+        context = @i18n.merge(context)
+      end
+      @metadata = context.fetch(:metadata, {})
+    end
+    
     def process_message
       if @i18n.kind_of?(Hash)
-        key = 'errawr.' + @key.to_s + '.error.message'
-        @message = I18n.t(key, @context, { default: I18n.t('errawr.unknown', @context) })
+        key = 'errawr.' + @key.to_s + '.message'
+        @message = I18n.t(key, @context.merge({ default: I18n.t('errawr.unknown', @context) }))
       else
         @message = I18n.t('errawr.' + @key.to_s, @context)
       end

data/lib/errawr/mapper.rb

@@ -15,9 +15,9 @@ module Errawr
     end
     
     def self.register!(key, options = {})
-      base_klass = options[:error] ? options[:error][:base_class] || Error : Error
+      base_klass = options[:base_class] || Error
       raise(ArgumentError, ':base_class must be a subclass of Errawr::Error') unless base_klass <= Error
-      klass = Class.new(base_klass).new(key, options.select { |k, v| ![:error].include?(k) })
+      klass = Class.new(base_klass).new(key, options)
       add(klass)
     end
     

data/lib/errawr/version.rb

@@ -1,3 +1,3 @@
 module Errawr
-  VERSION = '1.0.0'
+  VERSION = '1.1.0'
 end

data/lib/errawr.rb

@@ -9,6 +9,7 @@ module Errawr
   
   def self.error!(name, context = {})
     klass = Mapper[name] || Mapper[:unknown]
+    klass.metadata.merge!(context.delete(:metadata) || {})
     klass.context.merge!(context)
     raise klass
   end

data/spec/errawr_spec.rb

@@ -1,8 +1,64 @@
 require 'spec_helper'
 
 describe Errawr do
-  it 'should raise an Errawr::Error exception' do
-    Errawr.register!(:dummy_error)
-    expect { Errawr.error!(:dummy_error) }.to raise_error(Errawr::Error)
+  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
+    
+    it 'should return custom metadata values using #register!' do
+      Errawr.register!(:some_error, metadata: { name: 'custom_register!_name' })
+      begin
+        Errawr.error!(:some_error)
+      rescue => e
+        e.metadata[:name].should == 'custom_register!_name'
+      end
+    end
+    
+    it 'should return custom metadata values 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'
+      end
+    end
+    
+    it 'should return custom metadata values from locale file' do
+      Errawr.register!(:error_hash)
+      begin
+        Errawr.error!(:error_hash)
+      rescue => e
+        e.metadata.include?(:name).should be_true
+      end
+    end
+    
+    it '#register! should override custom metadata values from locale file' do
+      Errawr.register!(:error_hash, metadata: { name: 'register!_name' })
+      begin
+        Errawr.error!(:error_hash)
+      rescue => e
+        e.metadata[:name].should == 'register!_name'
+      end
+    end
+    
+    it 'should override custom metadata values from #register! and locale file' 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'
+      end
+    end
+    
+    it 'should interpolate locales' do
+      Errawr.register!(:interpolated_error, error_message: 'interpolated message')
+      begin
+        Errawr.error!(:interpolated_error)
+      rescue => e
+        e.message.should == 'Some error has occurred: interpolated message'
+      end
+    end
   end
 end

data/spec/error_spec.rb

@@ -1,11 +1,6 @@
 require 'spec_helper'
 
 describe Errawr::Error do
-  before(:each) do
-    I18n.load_path += Dir.glob('spec/support/en.yml')
-    I18n.reload!
-  end
-  
   it 'should return a key of :unknown if no key is set' do
     error = Errawr::Error.new
     error.key.should == :unknown
@@ -28,6 +23,6 @@ describe Errawr::Error do
   
   it 'should insert custom values into the context if I18n value is a hash' do
     error = Errawr::Error.new(:error_hash)
-    error.context[:name].should == 'error_name'
+    error.metadata[:name].should == 'error_name'
   end
 end

data/spec/mapper_spec.rb

@@ -20,7 +20,7 @@ describe Errawr::Mapper do
   
   describe 'register!' do
     it 'should throw an error if base class is not a subclass of Errawr::Error' do
-      expect { Errawr.register!(:dummy_error, { error: { base_class: StandardError } }) }.to raise_error(ArgumentError)
+      expect { Errawr.register!(:dummy_error, base_class: StandardError) }.to raise_error(ArgumentError)
     end
     
     it 'should add an error to stored errors' do
@@ -28,41 +28,12 @@ describe Errawr::Mapper do
       Errawr::Mapper[:dummy_error].should_not be_nil
     end
     
-    it 'should not add :error options to context' do
-      Errawr.register!(:dummy_error, error: { name: :same_dummy_error })
+    it 'should not add :metadata options to context' do
+      Errawr.register!(:dummy_error, metadata: { name: :same_dummy_error })
       begin
         Errawr.error!(:dummy_error)
       rescue => e
-        e.context.include?(:error).should be_false
-      end
-    end
-  end
-  
-  describe 'error!' do
-    it 'should return custom context values from locale file' do
-      Errawr.register!(:error_hash)
-      begin
-        Errawr.error!(:error_hash)
-      rescue => e
-        e.context.include?(:name).should be_true
-      end
-    end
-    
-    it '#register! should override custom context values from locale file' do
-      Errawr.register!(:error_hash, name: 'register!_name')
-      begin
-        Errawr.error!(:error_hash)
-      rescue => e
-        e.context[:name].should == 'register!_name'
-      end
-    end
-    
-    it '#error! should override custom context values from #register! and locale file' do
-      Errawr.register!(:error_hash, name: 'register!_name')
-      begin
-        Errawr.error!(:error_hash, name: 'error!_name')
-      rescue => e
-        e.context[:name].should == 'error!_name'
+        e.metadata.include?(:error).should be_false
       end
     end
   end

data/spec/spec_helper.rb

@@ -5,4 +5,11 @@ require 'errawr'
 
 # Require supporting ruby files with custom matchers and macros, etc,
 # in spec/support/ and its subdirectories.
-Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| puts f; require f }
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| puts f; require f }
+
+RSpec.configure do |config|
+  config.before(:each) do
+    I18n.load_path += Dir.glob('spec/support/en.yml')
+    I18n.reload!
+  end
+end

data/spec/support/en.yml

@@ -2,8 +2,11 @@ en:
   errawr:
     some_error: Some error has occurred
     error_hash:
-      name: error_name
-      error:
-        message: Some hashed error has occurred
+      message: Some hashed error has occurred
+      metadata:
+        name: error_name
     bad_error_hash:
-      name: bad_error
+      metadata:
+        name: bad_error
+    interpolated_error:
+      message: "Some error has occurred: %{error_message}"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: errawr
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Anthony Smith
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-16 00:00:00.000000000 Z
+date: 2013-11-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: i18n