hatch 0.0.6 → 0.0.7

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NWM5Y2NiNzZiYjYzYWQ5MWVhOWJkMjYyYTZjMWYyOThkY2JkNzg4Yg==
+    MzJjNWMxMjRlMzM0OGM0YTk2YWY3MmQ5YjAyZWNiMDZjYjg1YWQ0OA==
   data.tar.gz: !binary |-
-    YmVkMjEwZjRhZTEwMDY1MmRjMzNjZWUxZmJiYTdlOWZlMTgzNjFhMA==
+    NzJhNTQyYjJhMTUyOWZmOWE1OTdjMzY2ZDZmMDQ0MmViY2Y5ODEzZA==
 !binary "U0hBNTEy":
   metadata.gz: !binary |-
-    ZDYxZTI3ODQ5MzZmNjBhNTczNjdkMzgwZWY4MGU0ZThkNzdmNzFmMDc1MmRm
-    NzNjNWEwYTU3YjZhNGY5ZjM0OGE1NDU4NjlmNzRmOTIyZTE4NWY4Mjc5ZTI1
-    Y2U3NDk5OTJlM2ZjYjQ3MjkzMzFjZmIxOWRmYzc2MTk3MTE5M2Q=
+    MTY4NzUzN2Y3OGYyMWFlYmVmNGVjMTI1NDg5Yjc0Y2JiOGY2YmM4NWQyY2Fm
+    OTFlMTc0Y2Q5ZWE0YmFhODJkNTc4YWY3YjNhMmQ1MDU3ZWQyNzI1ZmIxZmFk
+    ZjA4ZDNlODYwMmY0NTgzMmQyYTY1YTFiMzQwNDc3YzBkMTVlYzY=
   data.tar.gz: !binary |-
-    MTI3ZjFmNWQwY2Q3MmU3ZDAwMjM4ZDNlMDZjNGIxZmQxZTRhZDMzYTY0N2Zm
-    N2FmNzM4ZjVmZjY1NmI1ZjI3OTM2MDI2NTY2MjU0ZDhhNTgwYWZjYzY3N2Uz
-    NTllYjk0OTBkYzhmMmYxZjA0MTE1OTRmZTQ2ZjI1OTM4MDNmOGQ=
+    M2E5M2QyNzE3YjE1NDRmZWM4MDAzNDg2ZjU1ZmY4YTNhMjRkODcxZjc1Yzg2
+    MmQyMGM4NzY0ZTU1NjIwNGQzNDlkNzc5MmQ4NTFhNjY5MzY3NjhiYmFiMTBk
+    ODQ5M2IwNjI0ZjYzNDdhN2MyMzQ5MWMzODBiNDg1ZWI5M2JjNTU=

data/README.md

@@ -1,11 +1,19 @@
 Hatch
 =====
 
+Installation
+------------
+
+    $ gem install hatch
+
+Usage
+-----
+
 An address without a street? A person without a name? Those are not valid objects!
 Why should you have them hanging around your system?
 
-Tell ```Hatch``` how to certify the attributes of your models, and he will give you
-the appropiate object.
+Tell `Hatch` how to certify the attributes of your models, and he will give you
+the appropriate object.
 
 If you don't hatch your model with all the correct attributes, it will give you
 an object representing an invalid instance of it.
@@ -29,38 +37,66 @@ end
 address = Address.hatch(street: 'Fake St', number: 1234)
 address.class
 # => Address
+address.valid?
+# => true
 
 not_an_address = Address.hatch(street: '', number: 1234)
 not_an_address.class
 # => Address::InvalidAddress
+not_an_address.valid?
+# => false
 ```
 
-You declare your attributes to ```Hatch``` with the ```attributes``` message and
-then use ```certify(:attribute, 'error message', &validation)``` to verify when an
+You declare your attributes to `Hatch` with the `attributes` message and
+then use `certify(:attribute, 'error message', &validation)` to verify when an
 attribute is valid.
 
-You'll also get some handy ```errors``` and ```valid?``` methods for both your valid
-and invalid model instances.
+In case you're wondering, the `Model::InvalidModel` is polymorphic with your
+`Model` in all the reader methods declared by `attr_reader` or `attr_accessor`
+
+`Hatch` also supports some common validations we all like to have! You can pass an error
+of your own or just use the default.
+
+```ruby
+class Address
+  include Hatch
+  attributes :street, :number
+
+  certifies(:street, :presence, "This is an error! Where's my street?!")
+  certifies(:number, :positive_number)
+end
+```
+
+Common validations come in the following flavours (along with default errors)
+
+  * `:presence` - `"must be present"`
+  * `:positive_number` - `"must be a positive number"`
+
+Aaand that's it for the moment. I'll keep on adding more as they come to my mind. If they come
+to yours first, feel free to add them and PR.
+
+Errors
+------
+
+You'll also get a handy `errors` hash with a couple of super powers.
 
 ```ruby
 not_an_address = Address.hatch(street: '', number: 1234)
 not_an_address.class
 # => Address::InvalidAddress
 
-not_an_address.errors
+not_an_address.errors.full_messages
 # => ['Address must have a street']
 
-not_an_address.valid?
-# => false
-```
-
-In case you're wondering, the ```Model::InvalidModel``` is polymorphic with your
-```Model``` in all the reader methods declared by ```attr_reader``` or ```attr_accessor```
+not_an_address.errors.on(:street)
+# => 'Address must have a street'
 
-Installation
-------------
+not_an_address.errors[:number]
+# => []
 
-    $ gem install hatch
+not_an_address.errors.empty?
+# => false
+```
 
 Thanks
 ------

data/hatch.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |s|
   s.name        = 'hatch'
-  s.version     = '0.0.6'
+  s.version     = '0.0.7'
   s.date        = Time.now.strftime('%Y-%m-%d')
   s.summary     = 'Keep valid objects only'
   s.description = "An address without a street? A person without a name? You don't need no invalid objects!"

data/lib/hatch.rb

@@ -58,7 +58,7 @@ module Hatch
 
       def initialize(*validated_attributes)
         @validated_attributes = validated_attributes
-        select_errors
+        @errors = Errors.build(@validated_attributes)
         respond_to_instance_methods
       end
 
@@ -80,12 +80,6 @@ module Hatch
           self.class.send :define_method, attribute.attr, -> {attribute.value}
         end
       end
-
-      def select_errors
-        @errors = @validated_attributes.select do |validated_attribute|
-          validated_attribute.invalid?
-        end.map(&:error)
-      end
     end
 
   private
@@ -151,5 +145,34 @@ module Hatch
       new(error || "must be a positive number") {|value| !value.nil? && value > 0}
     end
   end
+
+  class Errors < Hash
+    def self.build(validated_attributes)
+      errors = new
+      validated_attributes.each do |validated_attribute|
+        if validated_attribute.invalid?
+          errors[validated_attribute.attr] = validated_attribute.error
+        else
+          errors[validated_attribute.attr] = []
+        end
+      end
+
+      errors
+    end
+
+    def on(attr)
+      self[attr]
+    end
+
+    def full_messages
+      messages = []
+      values.each {|value| messages << value unless value.empty?}
+      messages
+    end
+
+    def empty?
+      full_messages.empty?
+    end
+  end
 end
 

data/test/common_validations_test.rb

@@ -13,13 +13,11 @@ end
 class CommonValidationsTest < Test::Unit::TestCase
   def test_presence
     common_stuff = CommonStuff.hatch(present: nil, positive: 1)
-    assert common_stuff.is_a?(CommonStuff::InvalidCommonStuff)
-    assert common_stuff.errors.include?("must be present")
+    assert_equal 'must be present', common_stuff.errors.on(:present)
   end
 
   def test_positive_number
-    common_stuff = CommonStuff.hatch(present: "here", positive: -1)
-    assert common_stuff.is_a?(CommonStuff::InvalidCommonStuff)
-    assert common_stuff.errors.include?("must be a positive number")
+    common_stuff = CommonStuff.hatch(present: 'here', positive: -1)
+    assert_equal 'must be a positive number', common_stuff.errors.on(:positive)
   end
 end

data/test/errors_test.rb

@@ -0,0 +1,27 @@
+require_relative 'support/helper'
+require_relative 'support/address'
+
+class ErrorsTest < Test::Unit::TestCase
+  def initialize(*args)
+    @address = Address.hatch(city: 'Buenos Aires', street: '', number: -1)
+    super
+  end
+
+  def test_errors_on
+    assert @address.errors.on(:city).empty?
+    assert_equal 'Address must have a street', @address.errors.on(:street)
+    assert_equal 'Address must have a positive number', @address.errors.on(:number)
+  end
+
+  def test_hash_accessor
+    assert @address.errors[:city].empty?
+    assert_equal 'Address must have a street', @address.errors[:street]
+    assert_equal 'Address must have a positive number', @address.errors[:number]
+  end
+
+  def test_errors_full_messages
+    assert @address.errors.full_messages.include?('Address must have a street')
+    assert @address.errors.full_messages.include?('Address must have a positive number')
+  end
+end
+

data/test/validation_test.rb

@@ -1,33 +1,17 @@
 require_relative 'support/helper'
 require_relative 'support/address'
 
-class ValidTest < Test::Unit::TestCase
+class ValidationTest < Test::Unit::TestCase
   def test_valid
-    address = Address.hatch(street: "Fake St", city: "Buenos Aires", number: 1234)
+    address = Address.hatch(street: 'Fake St', city: 'Buenos Aires', number: 1234)
     assert address.is_a?(Address)
-    assert_equal address.instance_variable_get("@street"), "Fake St"
-    assert_equal address.instance_variable_get("@number"), 1234
-    assert_equal address.instance_variable_get("@city"), "Buenos Aires"
-
-    assert address.respond_to?(:errors)
-    assert address.errors.empty?
     assert address.respond_to?(:valid?)
     assert address.valid?
   end
 
   def test_invalid
-    address = Address.hatch(city: "Buenos Aires", street: "", number: 1234)
-    assert address.is_a?(Address::InvalidAddress)
-    assert address.errors.include?("Address must have a street")
-    assert !address.errors.include?("Address must have a positive number")
-    assert !address.errors.include?("Address must have a city")
-
-    address = Address.hatch(street: "", number: -4)
+    address = Address.hatch(city: 'Buenos Aires', street: '', number: 1234)
     assert address.is_a?(Address::InvalidAddress)
-    assert address.errors.include?("Address must have a street")
-    assert address.errors.include?("Address must have a positive number")
-    assert address.errors.include?("Address must have a city")
-
     assert address.respond_to?(:valid?)
     assert !address.valid?
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hatch
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - Lucas Tolchinsky
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-21 00:00:00.000000000 Z
+date: 2013-05-31 00:00:00.000000000 Z
 dependencies: []
 description: An address without a street? A person without a name? You don't need
   no invalid objects!
@@ -22,6 +22,7 @@ files:
 - hatch.gemspec
 - Rakefile
 - test/common_validations_test.rb
+- test/errors_test.rb
 - test/polymorphism_test.rb
 - test/validation_test.rb
 - lib/hatch.rb