scrivener 0.0.2 → 0.0.3

data/README.md

@@ -37,6 +37,7 @@ chose to ignore the ones that come bundled with ORMs.
 This short example illustrates how to move the validation and whitelisting
 responsibilities away from the model and into Scrivener:
 
+```ruby
     # We use Sequel::Model in this example, but it applies to other ORMs such
     # as Ohm or ActiveRecord.
     class Article < Sequel::Model
@@ -60,15 +61,17 @@ responsibilities away from the model and into Scrivener:
 
     article.valid?            #=> false
     article.errors.on(:state) #=> ["cannot be empty"]
+```
 
 Of course, what you would do instead is declare `:title` and `:body` as allowed
 columns, then assign `:state` using the attribute accessor. The reason for this
 example is to show how you need to work around the fact that there's a single
 declaration for allowed columns and validations, which in many cases is a great
-feature and in other is a minor obstacle.
+feature and in others is a minor obstacle.
 
 Now see what happens with Scrivener:
 
+```ruby
     # Now the model has no validations or whitelists. It may still have schema
     # constraints, which is a good practice to enforce data integrity.
     class Article < Sequel::Model
@@ -110,13 +113,94 @@ Now see what happens with Scrivener:
     article.update_attributes(publish.attributes)
 
     # If we try to change other fields...
-    publish = Publish.new(status: "published", title: title)
+    publish = Publish.new(status: "published", title: "foo")
     #=> NoMethodError: undefined method `title=' for #<Publish...>
+```
 
 It's important to note that using Scrivener implies a greater risk than using
 the model validations. Having a central repository of mass assignable
 attributes and validations is more secure in most scenarios.
 
+
+Assertions
+-----------
+
+Scrivener ships with some basic assertions. The following is a brief description
+for each of them:
+
+### assert
+
+The `assert` method is used by all the other assertions. It pushes the
+second parameter to the list of errors if the first parameter evaluates
+to false.
+
+``` ruby
+    def assert(value, error)
+       value or errors[error.first].push(error.last) && false
+    end
+```
+
+### assert_present
+
+Checks that the given field is not nil or empty. The error code for this
+assertion is `:not_present`.
+
+### assert_format
+
+Checks that the given field matches the provided regular expression.
+The error code for this assertion is `:format`.
+
+### assert_numeric
+
+Checks that the given field holds a number as a Fixnum or as a string
+representation. The error code for this assertion is `:not_numeric`.
+
+### assert_url
+
+Provides a pretty general URL regular expression match. An important
+point to make is that this assumes that the URL should start with
+`http://` or `https://`. The error code for this assertion is
+`:not_url`.
+
+### assert_email
+
+In this current day and age, almost all web applications need to
+validate an email address. This pretty much matches 99% of the emails
+out there. The error code for this assertion is `:not_email`.
+
+### assert_member
+
+Checks that a given field is contained within a set of values (i.e.
+like an `ENUM`).
+
+``` ruby
+    def validate
+      assert_member :state, %w{pending paid delivered}
+    end
+```
+
+The error code for this assertion is `:not_valid`
+
+### assert_length
+
+Checks that a given field's length falls under a specified range.
+
+``` ruby
+    def validate
+      assert_length :username, 3..20
+    end
+```
+
+The error code for this assertion is `:not_in_range`.
+
+### assert_decimal
+
+Checks that a given field looks like a number in the human sense
+of the word. Valid numbers are: 0.1, .1, 1, 1.1, 3.14159, etc.
+
+The error code for this assertion is `:not_decimal`.
+
+
 Installation
 ------------
 

data/lib/scrivener.rb

@@ -1,7 +1,7 @@
 require File.expand_path("scrivener/validations", File.dirname(__FILE__))
 
 class Scrivener
-  VERSION = "0.0.2"
+  VERSION = "0.0.3"
 
   include Validations
 
@@ -49,7 +49,7 @@ class Scrivener
       instance_variables.each do |ivar|
         next if ivar == :@errors
 
-        att = ivar.to_s.sub(/@/, "").to_sym
+        att = ivar[1..-1].to_sym
         atts[att] = send(att)
       end
     end

data/lib/scrivener/validations.rb

@@ -7,6 +7,11 @@ class Scrivener
   # * assert_present
   # * assert_format
   # * assert_numeric
+  # * assert_url
+  # * assert_email
+  # * assert_member
+  # * assert_length
+  # * assert_decimal
   #
   # The core tenets that Scrivener::Validations advocates can be summed up in a
   # few bullet points:
@@ -121,10 +126,48 @@ class Scrivener
     # @see http://cyx.github.com/ohm-contrib/doc/Ohm/NumberValidations.html
     def assert_numeric(att, error = [att, :not_numeric])
       if assert_present(att, error)
-        assert_format(att, /^\d+$/, error)
+        assert_format(att, /\A\d+\z/, error)
       end
     end
 
+    URL = /\A(http|https):\/\/([a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}|(2
+          5[0-5]|2[0-4]\d|[0-1]?\d?\d)(\.(25[0-5]|2[0-4]\d|[0-1]?\d?\d)){3}
+          |localhost)(:[0-9]{1,5})?(\/.*)?\z/ix
+
+    def assert_url(att, error = [att, :not_url])
+      if assert_present(att, error)
+        assert_format(att, URL, error)
+      end
+    end
+
+    EMAIL = /\A([\w\!\#$\%\&\'\*\+\-\/\=\?\^\`{\|\}\~]+\.)*
+            [\w\!\#$\%\&\'\*\+\-\/\=\?\^\`{\|\}\~]+@
+            ((((([a-z0-9]{1}[a-z0-9\-]{0,62}[a-z0-9]{1})|[a-z])\.)+
+            [a-z]{2,6})|(\d{1,3}\.){3}\d{1,3}(\:\d{1,5})?)\z/ix
+
+    def assert_email(att, error = [att, :not_email])
+      if assert_present(att, error)
+        assert_format(att, EMAIL, error)
+      end
+    end
+
+    def assert_member(att, set, err = [att, :not_valid])
+      assert(set.include?(send(att)), err)
+    end
+
+    def assert_length(att, range, error = [att, :not_in_range])
+      if assert_present(att, error)
+        val = send(att).to_s
+        assert range.include?(val.length), error
+      end
+    end
+
+    DECIMAL = /\A(\d+)?(\.\d+)?\z/
+
+    def assert_decimal(att, error = [att, :not_decimal])
+      assert_format att, DECIMAL, 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.
     #
@@ -149,4 +192,3 @@ class Scrivener
     end
   end
 end
-

data/test/scrivener_test.rb

@@ -89,3 +89,105 @@ scope do
     assert_equal [:not_present], q.errors[:foo]
   end
 end
+
+class Post < Scrivener
+  attr_accessor :url, :email
+
+  def validate
+    assert_url :url
+    assert_email :email
+  end
+end
+
+scope do
+  test "email & url" do
+    p = Post.new({})
+
+    assert ! p.valid?
+    assert_equal [:not_url],  p.errors[:url]
+    assert_equal [:not_email],  p.errors[:email]
+
+    p = Post.new(url: "google.com", email: "egoogle.com")
+
+    assert ! p.valid?
+    assert_equal [:not_url],  p.errors[:url]
+    assert_equal [:not_email],  p.errors[:email]
+
+    p = Post.new(url: "http://google.com", email: "me@google.com")
+    assert p.valid?
+  end
+end
+
+class Person < Scrivener
+  attr_accessor :username
+
+  def validate
+    assert_length :username, 3..10
+  end
+end
+
+scope do
+  test "length validation" do
+    p = Person.new({})
+
+    assert ! p.valid?
+    assert p.errors[:username].include?(:not_in_range)
+
+    p = Person.new(username: "fo")
+    assert ! p.valid?
+    assert p.errors[:username].include?(:not_in_range)
+
+    p = Person.new(username: "foofoofoofo")
+    assert ! p.valid?
+    assert p.errors[:username].include?(:not_in_range)
+
+    p = Person.new(username: "foo")
+    assert p.valid?
+  end
+end
+
+class Order < Scrivener
+  attr_accessor :status
+
+  def validate
+    assert_member :status, %w{pending paid delivered}
+  end
+end
+
+scope do
+  test "member validation" do
+    o = Order.new({})
+    assert ! o.valid?
+    assert_equal [:not_valid], o.errors[:status]
+
+    o = Order.new(status: "foo")
+    assert ! o.valid?
+    assert_equal [:not_valid], o.errors[:status]
+
+    %w{pending paid delivered}.each do |status|
+      o = Order.new(status: status)
+      assert o.valid?
+    end
+  end
+end
+
+class Product < Scrivener
+  attr_accessor :price
+
+  def validate
+    assert_decimal :price
+  end
+end
+
+scope do
+  test "decimal validation" do
+    p = Product.new({})
+    assert ! p.valid?
+    assert_equal [:not_decimal], p.errors[:price]
+
+    %w{10 10.1 10.100000 0.100000 .1000}.each do |price|
+      p = Product.new(price: price)
+      assert p.valid?
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: scrivener
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,12 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-10-24 00:00:00.000000000 -03:00
-default_executable: 
+date: 2012-01-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cutest
-  requirement: &2156684860 !ruby/object:Gem::Requirement
+  requirement: &2156191960 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -22,7 +21,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *2156684860
+  version_requirements: *2156191960
 description: Scrivener removes the validation responsibility from models and acts
   as a filter for whitelisted attributes.
 email:
@@ -39,7 +38,6 @@ files:
 - lib/scrivener.rb
 - scrivener.gemspec
 - test/scrivener_test.rb
-has_rdoc: true
 homepage: http://github.com/soveran/scrivener
 licenses: []
 post_install_message: 
@@ -60,7 +58,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.6.2
+rubygems_version: 1.8.10
 signing_key: 
 specification_version: 3
 summary: Validation frontend for models.