scrivener 0.3.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: dc1f71859949ac9d78b3bc589d6d04ec70531240
-  data.tar.gz: 5bbd3d104350d6472cd03da0f18c1d90b6120dea
+SHA256:
+  metadata.gz: e94b74d62fa478e7e64a92078e84e8734897c3b2e5e7e7de2c158185aab79e34
+  data.tar.gz: c25c6bbb36c7c7d55ec6edbc037154dae6af10fd07210f790d17338148458020
 SHA512:
-  metadata.gz: dd5c732af472a97cfdd34d0091fa9eab509d9121d57369b1197cd259e7f1bdb8a02c7fdccf7746cf753819b838a00c8b456d1e856192f1f80fc228ad2b2ce60f
-  data.tar.gz: 2117ae9707e937dfa06d4ae54b99b8a299dcb6ead0aca9ca14a354e05fd570706b065bb344a5896cf9aad9b1346d2bd7f85bfad8aca33008e8516e6547ad2dd9
+  metadata.gz: 2c908c3f6be324ea81a909ec081669e6615b1810c692c3e1ef5cb95342188fcb133fdb5c69ff6312879ae37b26361b5abdf01382974e1560c257fffb662e28b2
+  data.tar.gz: acfb6f2cac8005c9d13e0c767cdec34258b85d6f29d59a5138e885a298e109ee6d56aea724e7b4cb1fc536e7299801e2c69fd11a0f192f1f458d5cdc4ff331e3

data/.gems

@@ -0,0 +1 @@
+cutest -v 1.2.2

data/.gitignore

@@ -0,0 +1 @@
+/pkg

data/CHANGELOG.md

@@ -0,0 +1,41 @@
+## 1.1.1
+
+* Avoid warning when forwarding arguments to #validate.
+
+## 1.1.0
+
+* Allow passing arguments to Scrivener#validate.
+
+## 1.0.0
+
+* Extra attributes are ignored.
+
+    ```ruby
+    # Before:
+
+    publish = Publish.new(status: "published", title: "foo")
+    publis.attributes # => { :status => "published" }
+    # => NoMethodError: undefined method `title=' for #<Publish...>
+
+    # Now:
+
+    # Extra fields are discarded
+    publish = Publish.new(status: "published", title: "foo")
+    publish.attributes # => { :status => "published" }
+    ```
+
+## 0.4.1
+
+* Fix creation of symbols for extra attributes.
+
+## 0.4.0
+
+* Fix `assert_email` and `assert_url` to support longer tld's.
+
+## 0.3.0
+
+* Add support for negative numbers.
+
+## 0.2.0
+
+* Add `assert_equal` validation.

data/CONTRIBUTING

@@ -0,0 +1,19 @@
+This code tries to solve a particular problem with a very simple
+implementation. We try to keep the code to a minimum while making
+it as clear as possible. The design is very likely finished, and
+if some feature is missing it is possible that it was left out on
+purpose. That said, new usage patterns may arise, and when that
+happens we are ready to adapt if necessary.
+
+A good first step for contributing is to meet us on IRC and discuss
+ideas. We spend a lot of time on #lesscode at freenode, always ready
+to talk about code and simplicity. If connecting to IRC is not an
+option, you can create an issue explaining the proposed change and
+a use case. We pay a lot of attention to use cases, because our
+goal is to keep the code base simple. Usually the result of a
+conversation is the creation of a different tool.
+
+Please don't start the conversation with a pull request. The code
+should come at last, and even though it may help to convey an idea,
+more often than not it draws the attention to a particular
+implementation.

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2011 Michel Martens
+Copyright (c) 2011-2015 Michel Martens
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -6,81 +6,18 @@ Validation frontend for models.
 Description
 -----------
 
-Scrivener removes the validation responsibility from models and acts as a
-filter for whitelisted attributes.
-
-A model may expose different APIs to satisfy different purposes. For example,
-the set of validations for a User in a Sign up process may not be the same
-as the one exposed to an Admin when editing a user profile. While you want
-the User to provide an email, a password and a password confirmation, you
-probably don't want the admin to mess with those attributes at all.
-
-In a wizard, different model states ask for different validations, and a single
-set of validations for the whole process is not the best solution.
-
-Scrivener is Bureaucrat's little brother. It draws all the inspiration from it
-and its features are a subset of Bureaucrat's. For a more robust and tested
-solution, please [check it](https://github.com/tizoc/bureaucrat).
-
-This library exists to satify the need of extracting Ohm's validations for
-reuse in other scenarios.
+Scrivener removes the validation responsibility from models and
+acts as a filter for whitelisted attributes. Read about the
+[motivation](#motivation) to understand why this separation of
+concerns is important.
 
 Usage
 -----
 
-Using Scrivener feels very natural no matter what underlying model you are
-using. As it provides its own validation and whitelisting features, you can
-choose 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:
+A very basic example would be creating a blog post:
 
 ```ruby
-# We use Sequel::Model in this example, but it applies to other ORMs such
-# as Ohm or ActiveRecord.
-class Article < Sequel::Model
-
-  # Whitelist for mass assigned attributes.
-  set_allowed_columns :title, :body, :state
-
-  # Validations for all contexts.
-  def validate
-    validates_presence :title
-    validates_presence :body
-    validates_presence :state
-  end
-end
-
-title = "Bartleby, the Scrivener"
-body  = "I am a rather elderly man..."
-
-# When using the model...
-article = Article.new(title: title, body: body)
-
-article.valid?            #=> false
-article.errors[:state] #=> [:not_present]
-```
-
-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 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
-end
-
-# The attribute accessors are the only fields that will be set. If more
-# fields are sent when using mass assignment, a NoMethodError exception is
-# raised.
-#
-# Note how in this example we don't accept the status attribute.
-class Edit < Scrivener
+class CreateBlogPost < Scrivener
   attr_accessor :title
   attr_accessor :body
 
@@ -89,44 +26,42 @@ class Edit < Scrivener
     assert_present :body
   end
 end
+```
 
-edit = Edit.new(title: title, body: body)
-edit.valid?               #=> true
-
-article = Article.new(edit.attributes)
-article.save
-
-# And now we only ask for the status.
-class Publish < Scrivener
-  attr_accessor :status
+In order to use it, you have to create an instance of `CreateBlogPost`
+by passing a hash with the attributes `title` and `body` and their
+corresponding values:
 
-  def validate
-    assert_format :status, /^(published|draft)$/
-  end
-end
+```ruby
+params = {
+  title: "Bartleby",
+  body: "I am a rather elderly man..."
+}
 
-publish = Publish.new(status: "published")
-publish.valid?            #=> true
+filter = CreateBlogPost.new(params)
+```
 
-article.update_attributes(publish.attributes)
+Now you can run the validations by calling `filter.valid?`, and you
+can retrieve the attributes by calling `filter.attributes`. If the
+validation fails, a hash of attributes and error codes will be
+available by calling `filter.errors`. For example:
 
-# If we try to change other fields...
-publish = Publish.new(status: "published", title: "foo")
-#=> NoMethodError: undefined method `title=' for #<Publish...>
+```ruby
+if filter.valid?
+  puts filter.attributes
+else
+  puts filter.errors
+end
 ```
 
-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.
+For now, we are just printing the attributes and the list of errors,
+but often you will use the attributes to create an instance of a
+model, and you will display the error messages in a view.
 
-Slices
-------
-
-If you don't need all the attributes after the filtering is done,
-you can fetch just the ones you need. For example:
+Let's consider the case of creating a new user:
 
 ```ruby
-class SignUp < Scrivener
+class CreateUser < Scrivener
   attr_accessor :email
   attr_accessor :password
   attr_accessor :password_confirmation
@@ -135,41 +70,79 @@ class SignUp < Scrivener
     assert_email :email
 
     if assert_present :password
-      assert_equal :password, :password_confirmation
+      assert_equal :password, password_confirmation
     end
   end
-
-  def assert_equal(f1, f2)
-    assert send(f1) == send(f2), [f1, f2, :not_equal]
-  end
 end
+```
+
+The filter looks very similar, but as you can see the validations
+return booleans, thus they can be nested. In this example, we don't
+want to bother asserting if the password and the password confirmation
+are equal if the password was not provided.
+
+Let's instantiate the filter:
 
-filter = SignUp.new(email: "info@example.com",
-                    password: "monkey",
-                    password_confirmation: "monkey")
+```ruby
+params = {
+  email: "info@example.com",
+  password: "monkey",
+  password_confirmation: "monkey"
+}
+
+filter = CreateUser.new(params)
+```
 
+If the validation succeeds, we only need email and password to
+create a new user, and we can discard the password_confirmation.
+The `filter.slice` method receives a list of attributes and returns
+the attributes hash with any other attributes removed. In this
+example, the hash returned by `filter.slice` will contain only the
+`email` and `password` fields:
 
-# If the validation succeeds, we only need email and password to
-# create a new user, and we can discard the password_confirmation.
+```ruby
 if filter.valid?
   User.create(filter.slice(:email, :password))
 end
 ```
 
-By calling `slice` with a list of attributes, you get a hash with only
-those key/value pairs.
+Sometimes we might want to use parameters from the outside for validation,
+but don't want the validator to treat them as attributes. In that case we
+can pass arguments to `#valid?`, and they will be forwarded to `#validate`.
+
+```ruby
+class CreateComment < Scrivener
+  attr_accessor :content
+  attr_accessor :article_id
+
+  def validate(available_articles:)
+    assert_present :content
+    assert_member :article_id, available_articles.map(&:id)
+  end
+end
+```
+
+```ruby
+params = {
+  content:    "this is a comment",
+  article_id: 57,
+}
+
+filter = CreateComment.new(params)
+
+filter.valid?(available_articles: user.articles)
+```
 
 Assertions
 -----------
 
-Scrivener ships with some basic assertions. The following is a brief description
-for each of them:
+Scrivener ships with some basic assertions.
 
 ### 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.
+to `false` or `nil`.
 
 ``` ruby
 def assert(value, error)
@@ -177,10 +150,23 @@ def assert(value, error)
 end
 ```
 
+New assertions can be built upon existing ones. For example, let's
+define an assertion for positive numbers:
+
+```ruby
+def assert_positive(att, error = [att, :not_positive])
+  assert(send(att) > 0, error)
+end
+```
+
+This assertion calls `assert` and passes both the result of evaluating
+`send(att) > 0` and the array with the attribute and the error code.
+All assertions respect this API.
+
 ### assert_present
 
-Checks that the given field is not nil or empty. The error code for this
-assertion is `:not_present`.
+Checks that the given field is not nil or empty. The error code for
+this assertion is `:not_present`.
 
 ### assert_equal
 
@@ -245,6 +231,36 @@ of the word. Valid numbers are: 0.1, .1, 1, 1.1, 3.14159, etc.
 
 The error code for this assertion is `:not_decimal`.
 
+Motivation
+----------
+
+A model may expose different APIs to satisfy different purposes.
+For example, the set of validations for a User in a sign up process
+may not be the same as the one exposed to an Admin when editing a
+user profile. While you want the User to provide an email, a password
+and a password confirmation, you probably don't want the admin to
+mess with those attributes at all.
+
+In a wizard, different model states ask for different validations,
+and a single set of validations for the whole process is not the
+best solution.
+
+This library exists to satisfy the need for extracting
+[Ohm](http://ohm.keyvalue.org)'s validations for reuse in other
+scenarios.
+
+Using Scrivener feels very natural no matter what underlying model
+you are using. As it provides its own validation and whitelisting
+features, you can choose to ignore those that come bundled with
+ORMs.
+
+See also
+--------
+
+Scrivener is [Bureaucrat](https://github.com/tizoc/bureaucrat)'s
+little brother. It draws all the inspiration from it and its features
+are a subset of Bureaucrat's.
+
 Installation
 ------------
 

data/lib/scrivener.rb

@@ -1,12 +1,12 @@
 require_relative "scrivener/validations"
 
 class Scrivener
-  VERSION = "0.3.0"
+  VERSION = "1.1.1"
 
   include Validations
 
   # Initialize with a hash of attributes and values.
-  # If extra attributes are sent, a NoMethodError exception will be raised.
+  # Extra attributes are discarded.
   #
   # @example
   #
@@ -36,17 +36,25 @@ class Scrivener
   #   post.save
   def initialize(atts)
     atts.each do |key, val|
-      send(:"#{key}=", val)
+      accessor = "#{key}="
+
+      if respond_to?(accessor)
+        send(accessor, val)
+      end
+    end
+  end
+
+  def _accessors
+    public_methods(false).select do |name|
+      name[-1] == "="
     end
   end
 
   # Return hash of attributes and values.
   def attributes
     Hash.new.tap do |atts|
-      instance_variables.each do |ivar|
-        next if ivar == :@errors
-
-        att = ivar[1..-1].to_sym
+      _accessors.each do |accessor|
+        att = accessor[0..-2].to_sym
         atts[att] = send(att)
       end
     end

data/lib/scrivener/validations.rb

@@ -67,14 +67,14 @@ class Scrivener
     #     end
     #   end
     #
-    def valid?
+    def valid?(*args, **kargs)
       errors.clear
-      validate
+      validate(*args, **kargs)
       errors.empty?
     end
 
     # Base validate implementation. Override this method in subclasses.
-    def validate
+    def validate(*args, **kargs)
     end
 
     # Hash of errors for each attribute in this model.
@@ -121,7 +121,7 @@ class Scrivener
       end
     end
 
-    URL = /\A(http|https):\/\/([a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}|(2
+    URL = /\A(http|https):\/\/([a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,12}|(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
 
@@ -134,7 +134,7 @@ class Scrivener
     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
+            [a-z]{2,12})|(\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)

data/makefile

@@ -0,0 +1,4 @@
+.PHONY: test
+
+test:
+	cutest test/**/*.rb

data/scrivener.gemspec

@@ -1,21 +1,16 @@
 require "./lib/scrivener"
 
 Gem::Specification.new do |s|
-  s.name              = "scrivener"
-  s.version           = Scrivener::VERSION
-  s.summary           = "Validation frontend for models."
-  s.description       = "Scrivener removes the validation responsibility from models and acts as a filter for whitelisted attributes."
-  s.authors           = ["Michel Martens"]
-  s.email             = ["michel@soveran.com"]
-  s.homepage          = "http://github.com/soveran/scrivener"
-  s.files = Dir[
-    "LICENSE",
-    "AUTHORS",
-    "README.md",
-    "Rakefile",
-    "lib/**/*.rb",
-    "*.gemspec",
-    "test/**/*.rb"
-  ]
+  s.name         = "scrivener"
+  s.version      = Scrivener::VERSION
+  s.summary      = "Validation frontend for models."
+  s.description  = "Scrivener removes the validation responsibility from models and acts as a filter for whitelisted attributes."
+  s.authors      = ["Michel Martens"]
+  s.email        = ["michel@soveran.com"]
+  s.homepage     = "http://github.com/soveran/scrivener"
+  s.license      = "MIT"
+
+  s.files = `git ls-files`.split("\n")
+
   s.add_development_dependency "cutest"
 end

data/test/scrivener_test.rb

@@ -6,12 +6,14 @@ class A < Scrivener
 end
 
 scope do
-  test "raise when there are extra fields" do
+  test "ignore extra fields" do
     atts = { :a => 1, :b => 2, :c => 3 }
 
-    assert_raise NoMethodError do
-      filter = A.new(atts)
-    end
+    filter = A.new(atts)
+
+    atts.delete(:c)
+
+    assert_equal atts, filter.attributes
   end
 
   test "not raise when there are less fields" do
@@ -123,6 +125,9 @@ scope do
 
     filter = D.new(url: "http://google.com", email: "me@google.com")
     assert filter.valid?
+
+    filter = D.new(url: "http://example.versicherung", email: "me@example.versicherung")
+    assert filter.valid?
   end
 end
 
@@ -202,61 +207,118 @@ end
 
 class H < Scrivener
   attr_accessor :a
+  attr_accessor :b
 
   def validate
-    assert_length :a, 3..10
+    assert_equal :a, "foo"
+    assert_equal :b, Integer
   end
 end
 
 scope do
-  test "length validation" do
+  test "equality validation" do
     filter = H.new({})
 
     assert ! filter.valid?
-    assert filter.errors[:a].include?(:not_in_range)
+    assert filter.errors[:a].include?(:not_equal)
+    assert filter.errors[:b].include?(:not_equal)
 
-    filter = H.new(a: "fo")
+    filter = H.new(a: "foo", b: "bar")
     assert ! filter.valid?
-    assert filter.errors[:a].include?(:not_in_range)
 
-    filter = H.new(a: "foofoofoofo")
+    filter = H.new(a: "foo")
     assert ! filter.valid?
-    assert filter.errors[:a].include?(:not_in_range)
+    assert filter.errors[:a].empty?
+    assert filter.errors[:b].include?(:not_equal)
 
-    filter = H.new(a: "foo")
+    filter = H.new(a: "foo", b: 42)
+    filter.valid?
     assert filter.valid?
   end
 end
 
+class Scrivener
+  def assert_filter(att, filter, error = nil)
+    filter = filter.new(send(att))
+    
+    unless filter.valid?
+      assert(false, error || [att, filter.errors])
+    end
+  end
+end
+
 class I < Scrivener
-  attr_accessor :a
-  attr_accessor :b
+  attr_accessor :name
+  
+  def validate
+    assert_equal :name, "I"
+  end
+end
+
+class J < Scrivener
+  attr_accessor :name
+  attr_accessor :i
 
   def validate
-    assert_equal :a, "foo"
-    assert_equal :b, Fixnum
+    assert_equal :name, "J"
+    assert_filter :i, I
   end
 end
 
+scope do
+  test "nested filters" do
+    j1 = J.new(name: "J", i: { name: "I" })
+    j2 = J.new(name: "J", i: { name: "H" })
+
+    assert_equal true, j1.valid?
+    assert_equal false, j2.valid?
+
+    errors = {
+      i: [{ name: [:not_equal] }]
+    }
+
+    assert_equal errors, j2.errors
+  end
+end
+
+class K < Scrivener
+  def validate(argument)
+    assert argument == "K", [:k, :not_valid]
+  end
+end
 
 scope do
-  test "equality validation" do
-    filter = I.new({})
+  test "passing arguments" do
+    k = K.new({})
 
-    assert ! filter.valid?
-    assert filter.errors[:a].include?(:not_equal)
-    assert filter.errors[:b].include?(:not_equal)
+    assert_equal true,  k.valid?("K")
+    assert_equal false, k.valid?("L")
 
-    filter = I.new(a: "foo", b: "bar")
-    assert ! filter.valid?
+    errors = {
+      k: [:not_valid]
+    }
 
-    filter = I.new(a: "foo")
-    assert ! filter.valid?
-    assert filter.errors[:a].empty?
-    assert filter.errors[:b].include?(:not_equal)
+    assert_equal errors, k.errors
+  end
+end
 
-    filter = I.new(a: "foo", b: 42)
-    filter.valid?
-    assert filter.valid?
+class L < Scrivener
+  def validate(argument, key:)
+    assert argument == "L" && key == "L", [:l, :not_valid]
+  end
+end
+
+scope do
+  test "passing keyword arguments" do
+    l = L.new({})
+
+    assert_equal true,  l.valid?("L", key: "L")
+    assert_equal false, l.valid?("M", key: "M")
+
+    errors = {
+      l: [:not_valid]
+    }
+
+    assert_equal errors, l.errors
   end
 end

metadata

@@ -1,27 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: scrivener
 version: !ruby/object:Gem::Version
-  version: 0.3.0
+  version: 1.1.1
 platform: ruby
 authors:
 - Michel Martens
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-30 00:00:00.000000000 Z
+date: 2020-07-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: cutest
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '>='
+    - - ">="
       - !ruby/object:Gem::Version
         version: '0'
 description: Scrivener removes the validation responsibility from models and acts
@@ -32,16 +32,21 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- LICENSE
+- ".gems"
+- ".gitignore"
 - AUTHORS
+- CHANGELOG.md
+- CONTRIBUTING
+- LICENSE
 - README.md
-- Rakefile
-- lib/scrivener/validations.rb
 - lib/scrivener.rb
+- lib/scrivener/validations.rb
+- makefile
 - scrivener.gemspec
 - test/scrivener_test.rb
 homepage: http://github.com/soveran/scrivener
-licenses: []
+licenses:
+- MIT
 metadata: {}
 post_install_message: 
 rdoc_options: []
@@ -49,17 +54,16 @@ require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.0.14
+rubygems_version: 3.1.2
 signing_key: 
 specification_version: 4
 summary: Validation frontend for models.

data/Rakefile

@@ -1,6 +0,0 @@
-task :test do
-  require "cutest"
-  Cutest.run(Dir["test/*.rb"])
-end
-
-task :default => :test