scrivener 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a1646faeced5318ac81a17b7fc8d05b59508b0d9
-  data.tar.gz: 80b3fa99edfe7c6e079bafa33fe3e90870701d5d
+  metadata.gz: a106b8c9aa9ba83fc66fec4afc4c030da9f25291
+  data.tar.gz: d5918f87defb857d0870932c1914db935497aca8
 SHA512:
-  metadata.gz: 207456238ab18834fa1ab9834610e19a20def26196fac1780edaee47ed6046d2581cbae5c0a07e58877c4a30b85e5a3a347b21406b0a910900ae19488c5e1ea7
-  data.tar.gz: 5a8fe4ca21cd06578fa4287324f44ce58420ac8c9f7d87f1dccd34e0df3348eb7c2c10aa176a2ec6dd52cce3649a68af8dc1afdc152f789af22f1b4d2caecb27
+  metadata.gz: 5afc2e5969db3a93670a20ede2992d3a1e095369d4407292bda46956f3d50fa8bc857d1dc9233adaf45fb044f99bdc672414fc0dc58655cc3ee1dc6d02295cd6
+  data.tar.gz: cab3e3c0e586c192768ce7788359cfcb0fd36a8b8681f7097a5cd4deeeddf544fc0482fffba70e09cf3708dbee3b752c5726649c1c3e89ccd56a8e6eb6e2413e

data/README.md

@@ -184,6 +184,14 @@ end
 Checks that the given field is not nil or empty. The error code for this
 assertion is `:not_present`.
 
+### assert_equal
+
+Check that the attribute has the expected value. It uses === for
+comparison, so type checks are possible too. Note that in order to
+make the case equality work, the check inverts the order of the
+arguments: `assert_equal :foo, Bar` is translated to the expression
+`Bar === send(:foo)`.
+
 ### assert_format
 
 Checks that the given field matches the provided regular expression.

data/lib/scrivener.rb

@@ -1,7 +1,7 @@
 require_relative "scrivener/validations"
 
 class Scrivener
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 
   include Validations
 

data/lib/scrivener/validations.rb

@@ -12,6 +12,7 @@ class Scrivener
   # * assert_member
   # * assert_length
   # * assert_decimal
+  # * assert_equal
   #
   # The core tenets that Scrivener::Validations advocates can be summed up in a
   # few bullet points:
@@ -168,6 +169,27 @@ class Scrivener
       assert_format att, DECIMAL, error
     end
 
+    # Check that the attribute has the expected value. It uses === for
+    # comparison, so type checks are possible too. Note that in order
+    # to make the case equality work, the check inverts the order of
+    # the arguments: `assert_equal :foo, Bar` is translated to the
+    # expression `Bar === send(:foo)`.
+    # 
+    # @example
+    # 
+    #   def validate
+    #     assert_equal :status, "pending"
+    #     assert_equal :quantity, Fixnum
+    #   end
+    #
+    # @param [Symbol] att The attribute you wish to verify for equality.
+    # @param [Object] value The value you want to test against.
+    # @param [Array<Symbol, Symbol>] error The error that should be returned
+    #                                when the validation fails.
+    def assert_equal(att, value, error = [att, :not_equal])
+      assert value === send(att), error
+    end
+
     # The grand daddy of all assertions. If you want to build custom
     # assertions, or even quick and dirty ones, you can simply use this method.
     #

data/test/scrivener_test.rb

@@ -1,6 +1,6 @@
 require File.expand_path("../lib/scrivener", File.dirname(__FILE__))
 
-class S < Scrivener
+class A < Scrivener
   attr_accessor :a
   attr_accessor :b
 end
@@ -10,34 +10,34 @@ scope do
     atts = { :a => 1, :b => 2, :c => 3 }
 
     assert_raise NoMethodError do
-      s = S.new(atts)
+      filter = A.new(atts)
     end
   end
 
   test "not raise when there are less fields" do
     atts = { :a => 1 }
 
-    assert s = S.new(atts)
+    assert filter = A.new(atts)
   end
 
   test "return attributes" do
     atts = { :a => 1, :b => 2 }
 
-    s = S.new(atts)
+    filter = A.new(atts)
 
-    assert_equal atts, s.attributes
+    assert_equal atts, filter.attributes
   end
 
   test "return only the required attributes" do
     atts = { :a => 1, :b => 2 }
 
-    s = S.new(atts)
+    filter = A.new(atts)
 
-    assert_equal s.slice(:a), { :a => 1 }
+    assert_equal filter.slice(:a), { :a => 1 }
   end
 end
 
-class T < Scrivener
+class B < Scrivener
   attr_accessor :a
   attr_accessor :b
 
@@ -51,54 +51,54 @@ scope do
   test "validations" do
     atts = { :a => 1, :b => 2 }
 
-    t = T.new(atts)
+    filter = B.new(atts)
 
-    assert t.valid?
+    assert filter.valid?
   end
 
   test "validation errors" do
     atts = { :a => 1 }
 
-    t = T.new(atts)
+    filter = B.new(atts)
 
-    assert_equal false, t.valid?
-    assert_equal [], t.errors[:a]
-    assert_equal [:not_present], t.errors[:b]
+    assert_equal false, filter.valid?
+    assert_equal [], filter.errors[:a]
+    assert_equal [:not_present], filter.errors[:b]
   end
 
   test "attributes without @errors" do
     atts = { :a => 1, :b => 2 }
 
-    t = T.new(atts)
+    filter = B.new(atts)
 
-    t.valid?
-    assert_equal atts, t.attributes
+    filter.valid?
+    assert_equal atts, filter.attributes
   end
 end
 
-class Quote
+class C
   include Scrivener::Validations
 
-  attr_accessor :foo
+  attr_accessor :a
 
   def validate
-    assert_present :foo
+    assert_present :a
   end
 end
 
 scope do
   test "validations without Scrivener" do
-    q = Quote.new
-    q.foo = 1
-    assert q.valid?
+    filter = C.new
+    filter.a = 1
+    assert filter.valid?
 
-    q = Quote.new
-    assert_equal false, q.valid?
-    assert_equal [:not_present], q.errors[:foo]
+    filter = C.new
+    assert_equal false, filter.valid?
+    assert_equal [:not_present], filter.errors[:a]
   end
 end
 
-class Post < Scrivener
+class D < Scrivener
   attr_accessor :url, :email
 
   def validate
@@ -109,52 +109,52 @@ end
 
 scope do
   test "email & url" do
-    p = Post.new({})
+    filter = D.new({})
 
-    assert ! p.valid?
-    assert_equal [:not_url],  p.errors[:url]
-    assert_equal [:not_email],  p.errors[:email]
+    assert ! filter.valid?
+    assert_equal [:not_url],  filter.errors[:url]
+    assert_equal [:not_email],  filter.errors[:email]
 
-    p = Post.new(url: "google.com", email: "egoogle.com")
+    filter = D.new(url: "google.com", email: "egoogle.com")
 
-    assert ! p.valid?
-    assert_equal [:not_url],  p.errors[:url]
-    assert_equal [:not_email],  p.errors[:email]
+    assert ! filter.valid?
+    assert_equal [:not_url],  filter.errors[:url]
+    assert_equal [:not_email],  filter.errors[:email]
 
-    p = Post.new(url: "http://google.com", email: "me@google.com")
-    assert p.valid?
+    filter = D.new(url: "http://google.com", email: "me@google.com")
+    assert filter.valid?
   end
 end
 
-class Person < Scrivener
-  attr_accessor :username
+class E < Scrivener
+  attr_accessor :a
 
   def validate
-    assert_length :username, 3..10
+    assert_length :a, 3..10
   end
 end
 
 scope do
   test "length validation" do
-    p = Person.new({})
+    filter = E.new({})
 
-    assert ! p.valid?
-    assert p.errors[:username].include?(:not_in_range)
+    assert ! filter.valid?
+    assert filter.errors[:a].include?(:not_in_range)
 
-    p = Person.new(username: "fo")
-    assert ! p.valid?
-    assert p.errors[:username].include?(:not_in_range)
+    filter = E.new(a: "fo")
+    assert ! filter.valid?
+    assert filter.errors[:a].include?(:not_in_range)
 
-    p = Person.new(username: "foofoofoofo")
-    assert ! p.valid?
-    assert p.errors[:username].include?(:not_in_range)
+    filter = E.new(a: "foofoofoofo")
+    assert ! filter.valid?
+    assert filter.errors[:a].include?(:not_in_range)
 
-    p = Person.new(username: "foo")
-    assert p.valid?
+    filter = E.new(a: "foo")
+    assert filter.valid?
   end
 end
 
-class Order < Scrivener
+class F < Scrivener
   attr_accessor :status
 
   def validate
@@ -164,38 +164,99 @@ end
 
 scope do
   test "member validation" do
-    o = Order.new({})
-    assert ! o.valid?
-    assert_equal [:not_valid], o.errors[:status]
+    filter = F.new({})
+    assert ! filter.valid?
+    assert_equal [:not_valid], filter.errors[:status]
 
-    o = Order.new(status: "foo")
-    assert ! o.valid?
-    assert_equal [:not_valid], o.errors[:status]
+    filter = F.new(status: "foo")
+    assert ! filter.valid?
+    assert_equal [:not_valid], filter.errors[:status]
 
     %w{pending paid delivered}.each do |status|
-      o = Order.new(status: status)
-      assert o.valid?
+      filter = F.new(status: status)
+      assert filter.valid?
     end
   end
 end
 
-class Product < Scrivener
-  attr_accessor :price
+class G < Scrivener
+  attr_accessor :a
 
   def validate
-    assert_decimal :price
+    assert_decimal :a
   end
 end
 
 scope do
   test "decimal validation" do
-    p = Product.new({})
-    assert ! p.valid?
-    assert_equal [:not_decimal], p.errors[:price]
+    filter = G.new({})
+    assert ! filter.valid?
+    assert_equal [:not_decimal], filter.errors[:a]
 
-    %w{10 10.1 10.100000 0.100000 .1000}.each do |price|
-      p = Product.new(price: price)
-      assert p.valid?
+    %w{10 10.1 10.100000 0.100000 .1000}.each do |a|
+      filter = G.new(a: a)
+      assert filter.valid?
     end
   end
 end
+
+class H < Scrivener
+  attr_accessor :a
+
+  def validate
+    assert_length :a, 3..10
+  end
+end
+
+scope do
+  test "length validation" do
+    filter = H.new({})
+
+    assert ! filter.valid?
+    assert filter.errors[:a].include?(:not_in_range)
+
+    filter = H.new(a: "fo")
+    assert ! filter.valid?
+    assert filter.errors[:a].include?(:not_in_range)
+
+    filter = H.new(a: "foofoofoofo")
+    assert ! filter.valid?
+    assert filter.errors[:a].include?(:not_in_range)
+
+    filter = H.new(a: "foo")
+    assert filter.valid?
+  end
+end
+
+class I < Scrivener
+  attr_accessor :a
+  attr_accessor :b
+
+  def validate
+    assert_equal :a, "foo"
+    assert_equal :b, Fixnum
+  end
+end
+
+
+scope do
+  test "equality validation" do
+    filter = I.new({})
+
+    assert ! filter.valid?
+    assert filter.errors[:a].include?(:not_equal)
+    assert filter.errors[:b].include?(:not_equal)
+
+    filter = I.new(a: "foo", b: "bar")
+    assert ! filter.valid?
+
+    filter = I.new(a: "foo")
+    assert ! filter.valid?
+    assert filter.errors[:a].empty?
+    assert filter.errors[:b].include?(:not_equal)
+
+    filter = I.new(a: "foo", b: 42)
+    filter.valid?
+    assert filter.valid?
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: scrivener
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Michel Martens
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-04-25 00:00:00.000000000 Z
+date: 2013-05-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cutest