opal-scrivener 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 69be06e09445d99a285f4672cb17347b7cdfeea4
+  data.tar.gz: b2c8e116c64a665ece1a5e67177f1fb6e6b9193d
+SHA512:
+  metadata.gz: f2762dafc01d96c4651566a2a73fa2e25aea7a6497bd96a67692671741ceab402de649d8bea97fdf0faa58207c57fb28b8f47f84f007c084a3b43f9b2cf057e5
+  data.tar.gz: 53bde447f9322660cee1b50ea1c18b9fd9411eeaf17e73f41f819985de1c9a2fa19674d83742ff676bfbaf920eb0c58f33324aa8daaebd19167335714758ebaf

data/.bundle/config

@@ -0,0 +1,2 @@
+---
+BUNDLE_DISABLE_SHARED_GEMS: '1'

data/.gems

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

data/.gitignore

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

data/AUTHORS

@@ -0,0 +1,3 @@
+* Cyril David (cyx)
+* Lucas Nasif (ehqhvm)
+* Michel Martens (soveran)

data/CHANGELOG.md

@@ -0,0 +1,33 @@
+## 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

@@ -0,0 +1,19 @@
+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
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,243 @@
+Scrivener
+=========
+
+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.
+
+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:
+
+```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
+  attr_accessor :title
+  attr_accessor :body
+
+  def validate
+    assert_present :title
+    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
+
+  def validate
+    assert_format :status, /^(published|draft)$/
+  end
+end
+
+publish = Publish.new(status: "published")
+publish.valid?            #=> true
+
+article.update_attributes(publish.attributes)
+
+# Extra fields are discarded
+publish = Publish.new(status: "published", title: "foo")
+publish.attributes #=> { :status => "published" }
+```
+
+Slices
+------
+
+If you don't need all the attributes after the filtering is done,
+you can fetch just the ones you need. For example:
+
+```ruby
+class SignUp < Scrivener
+  attr_accessor :email
+  attr_accessor :password
+  attr_accessor :password_confirmation
+
+  def validate
+    assert_email :email
+
+    if assert_present :password
+      assert_equal :password, password_confirmation
+    end
+  end
+end
+
+filter = SignUp.new(email: "info@example.com",
+                    password: "monkey",
+                    password_confirmation: "monkey")
+
+
+# If the validation succeeds, we only need email and password to
+# create a new user, and we can discard the password_confirmation.
+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.
+
+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_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.
+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
+------------
+
+    $ gem install scrivener

data/lib/opal-scrivener.rb

@@ -0,0 +1,5 @@
+require 'scrivener'
+
+unless RUBY_ENGINE == 'opal'
+  Opal.append_path File.expand_path('..', __FILE__).untaint
+end

data/lib/scrivener/types.rb

@@ -0,0 +1,88 @@
+require "time"
+require "date"
+require "bigdecimal"
+
+class Scrivener
+  # Provides a way to define attributes so they are cast into a corresponding
+  # type (defaults to +String+) when getting the attributes.
+  #
+  # Any object that supports a .call method can be used as a "type". The
+  # following are implemented out of the box:
+  #
+  # - Types::Symbol
+  # - Types::String
+  # - Types::Integer
+  # - Types::Float
+  # - Types::Decimal
+  # - Types::Date
+  # - Types::Time
+  # - Types::DateTime
+  # - Types::Boolean
+  #
+  # @example
+  #
+  #   class CreateProduct < Scrivener
+  #     attribute :name
+  #     attribute :description
+  #     attribute :price,           Types::Decimal
+  #     attribute :avaliable_after, Types::Date
+  #     attribute :stock,           Types::Integer
+  #   end
+  #
+  #   p = CreateProduct.new(name: "Foo", price: "10.0", available_after: "2012-07-10")
+  #   p.cleaned_price #=> BigDecimal.new("10.0")
+  #   p.cleaned_available_after #=> Date.new(2012, 7, 10)
+  #   p.cleaned_name #=> "Foo"
+  #
+  module Types
+    Symbol   = ->(value) { value.to_sym }
+    String   = ->(value) { value.to_s }
+    Integer  = ->(value) { Integer(value) }
+    Float    = ->(value) { Float(value) }
+    Decimal  = ->(value) { BigDecimal(value) }
+    Date     = ->(value) { ::Date.parse(value.to_s) }
+    DateTime = ->(value) { ::DateTime.parse(value.to_s) }
+    Time     = ->(value) { ::Time.parse(value.to_s) }
+    Boolean  = ->(value) {
+      case value
+      when "f", "false", "0"; false
+      when "t", "true", "1"; true
+      else !!value
+      end
+    }
+
+    # Define an attribute with its corresponding type. This is similar to
+    # attr_accessor, except the reader method will cast the object into the
+    # proper type.
+    #
+    # If the casting results in a TypeError or ArgumentError, then an error on
+    # :typecast will be added to this attribute and the raw attribute will be
+    # returned instead.
+    #
+    # @param [Symbol] name The name of the attribute.
+    # @param [#call]  type The type of this attribute (defaults to String).
+    #
+    # @example
+    #
+    #   attribute :foo
+    #   attribute :foo, Types::String
+    #   attribute :foo, Types::Date
+    #
+    # @!macro [attach] attribute
+    #   @return [$2] the $1 attribute.
+    #
+    def attribute(name, type=Types::String)
+      attr_writer name
+
+      define_method name do
+        begin
+          val = instance_variable_get(:"@#{name}")
+          val && type.call(val)
+        rescue TypeError, ArgumentError
+          errors[name].push(:typecast)
+          val
+        end
+      end
+    end
+  end
+end

data/lib/scrivener/validations.rb

@@ -0,0 +1,225 @@
+class Scrivener
+
+  # Provides a base implementation for extensible validation routines.
+  # {Scrivener::Validations} currently only provides the following assertions:
+  #
+  # * assert
+  # * assert_present
+  # * assert_format
+  # * assert_numeric
+  # * assert_url
+  # * assert_email
+  # * assert_member
+  # * assert_length
+  # * assert_decimal
+  # * assert_equal
+  #
+  # The core tenets that Scrivener::Validations advocates can be summed up in a
+  # few bullet points:
+  #
+  # 1. Validations are much simpler and better done using composition rather
+  #    than macros.
+  # 2. Error messages should be kept separate and possibly in the view or
+  #    presenter layer.
+  # 3. It should be easy to write your own validation routine.
+  #
+  # Other validations are simply added on a per-model or per-project basis.
+  #
+  # @example
+  #
+  #   class Quote
+  #     attr_accessor :title
+  #     attr_accessor :price
+  #     attr_accessor :date
+  #
+  #     def validate
+  #       assert_present :title
+  #       assert_numeric :price
+  #       assert_format  :date, /\A[\d]{4}-[\d]{1,2}-[\d]{1,2}\z
+  #     end
+  #   end
+  #
+  #   s = Quote.new
+  #   s.valid?
+  #   # => false
+  #
+  #   s.errors
+  #   # => { :title => [:not_present],
+  #          :price => [:not_numeric],
+  #          :date  => [:format] }
+  #
+  module Validations
+
+    # Check if the current model state is valid. Each call to {#valid?} will
+    # reset the {#errors} array.
+    #
+    # All validations should be declared in a `validate` method.
+    #
+    # @example
+    #
+    #   class Login
+    #     attr_accessor :username
+    #     attr_accessor :password
+    #
+    #     def validate
+    #       assert_present :user
+    #       assert_present :password
+    #     end
+    #   end
+    #
+    def valid?
+      errors.clear
+      validate
+      errors.empty?
+    end
+
+    # Base validate implementation. Override this method in subclasses.
+    def validate
+    end
+
+    # Hash of errors for each attribute in this model.
+    def errors
+      @errors ||= Hash.new { |hash, key| hash[key] = [] }
+    end
+
+  protected
+
+    # Allows you to do a validation check against a regular expression.
+    # It's important to note that this internally calls {#assert_present},
+    # therefore you need not structure your regular expression to check
+    # for a non-empty value.
+    #
+    # @param [Symbol] att The attribute you want to verify the format of.
+    # @param [Regexp] format The regular expression with which to compare
+    #                 the value of att with.
+    # @param [Array<Symbol, Symbol>] error The error that should be returned
+    #                                when the validation fails.
+    def assert_format(att, format, error = [att, :format])
+      if assert_present(att, error)
+        assert(send(att).to_s.match(format), error)
+      end
+    end
+
+    # The most basic and highly useful assertion. Simply checks if the
+    # value of the attribute is empty.
+    #
+    # @param [Symbol] att The attribute you wish to verify the presence of.
+    # @param [Array<Symbol, Symbol>] error The error that should be returned
+    #                                when the validation fails.
+    def assert_present(att, error = [att, :not_present])
+      assert(!send(att).to_s.empty?, error)
+    end
+
+    # Checks if all the characters of an attribute is a digit.
+    #
+    # @param [Symbol] att The attribute you wish to verify the numeric format.
+    # @param [Array<Symbol, Symbol>] error The error that should be returned
+    #                                when the validation fails.
+    def assert_numeric(att, error = [att, :not_numeric])
+      if assert_present(att, error)
+        value = send(att)
+
+        if RUBY_ENGINE == 'opal'
+          assert(value.respond_to?(:to_int) || value.to_s.match(/^\-?\d+$/), error)
+        else
+          assert(value.respond_to?(:to_int) || value.to_s.match(/\A\-?\d+\z/), error)
+        end
+      end
+    end
+
+    if RUBY_ENGINE == 'opal'
+      URL = /^(http|https):\/\/([a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,12}|(25[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})?(\/.*)?$/i
+    else
+      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
+    end
+
+    def assert_url(att, error = [att, :not_url])
+      if assert_present(att, error)
+        assert_format(att, URL, error)
+      end
+    end
+
+
+    if RUBY_ENGINE == 'opal'
+      EMAIL = /^([\w\!\#$\%\&\'\*\+\-\/\=\?\^\`{\|\}\~]+\.)*[\w\!\#$\%\&\'\*\+\-\/\=\?\^\`{\|\}\~]+@((((([a-z0-9]{1}[a-z0-9\-]{0,62}[a-z0-9]{1})|[a-z])\.)+[a-z]{2,12})|(\d{1,3}\.){3}\d{1,3}(\:\d{1,5})?)$/i
+    else
+      EMAIL = /\A([\w\!\#$\%\&\'\*\+\-\/\=\?\^\`{\|\}\~]+\.)*
+              [\w\!\#$\%\&\'\*\+\-\/\=\?\^\`{\|\}\~]+@
+              ((((([a-z0-9]{1}[a-z0-9\-]{0,62}[a-z0-9]{1})|[a-z])\.)+
+              [a-z]{2,12})|(\d{1,3}\.){3}\d{1,3}(\:\d{1,5})?)\z/ix
+    end
+
+    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
+
+    if RUBY_ENGINE == 'opal'
+      DECIMAL = /^\-?(\d+)?(\.\d+(E\d+)?)$/
+    else
+      DECIMAL = /\A\-?(\d+)?(\.\d+(E\d+)?)?\z/
+    end
+
+    def assert_decimal(att, error = [att, :not_decimal])
+      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.
+    #
+    # @example
+    #
+    #   class CreatePost
+    #     attr_accessor :slug
+    #     attr_accessor :votes
+    #
+    #     def validate
+    #       assert_slug :slug
+    #       assert votes.to_i > 0, [:votes, :not_valid]
+    #     end
+    #
+    #   protected
+    #     def assert_slug(att, error = [att, :not_slug])
+    #       assert send(att).to_s =~ /\A[a-z\-0-9]+\z/, error
+    #     end
+    #   end
+    def assert(value, error)
+      value or errors[error.first].push(error.last) && false
+    end
+  end
+end

data/lib/scrivener.rb

@@ -0,0 +1,74 @@
+require_relative "scrivener/validations"
+require_relative "scrivener/types"
+
+class Scrivener
+  VERSION = "1.0.0"
+
+  include Validations
+  extend Types
+
+  # Initialize with a hash of attributes and values.
+  # Extra attributes are discarded.
+  #
+  # @example
+  #
+  #   class EditPost < Scrivener
+  #     attr_accessor :title
+  #     attr_accessor :body
+  #
+  #     def validate
+  #       assert_present :title
+  #       assert_present :body
+  #     end
+  #   end
+  #
+  #   edit = EditPost.new(title: "Software Tools")
+  #
+  #   edit.valid? #=> false
+  #
+  #   edit.errors[:title] #=> []
+  #   edit.errors[:body]  #=> [:not_present]
+  #
+  #   edit.body = "Recommended reading..."
+  #
+  #   edit.valid? #=> true
+  #
+  #   # Now it's safe to initialize the model.
+  #   post = Post.new(edit.attributes)
+  #   post.save
+  def initialize(atts)
+    @_accessors = atts.keys.map { |key| "#{key}=".to_sym }
+
+    atts.each do |key, val|
+      accessor = "#{key}="
+
+      if respond_to?(accessor)
+        send(accessor, val)
+      end
+    end
+  end
+
+  def _accessors
+    @_accessors & public_methods(false).select do |name|
+      name[-1] == "="
+    end
+  end
+
+  # Return hash of attributes and values.
+  def attributes
+    Hash.new.tap do |atts|
+      _accessors.each do |accessor|
+        att = accessor[0..-2].to_sym
+        atts[att] = send(att)
+      end
+    end
+  end
+
+  def slice(*keys)
+    Hash.new.tap do |atts|
+      keys.each do |att|
+        atts[att] = send(att)
+      end
+    end
+  end
+end

data/makefile

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

data/opal-scrivener.gemspec

@@ -0,0 +1,16 @@
+require "./lib/scrivener"
+
+Gem::Specification.new do |s|
+  s.name         = "opal-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.  Works with Opal."
+  s.authors      = ["Michel Martens", "CJ Lazell"]
+  s.email        = ["michel@soveran.com", "cjlazell@gmail.com"]
+  s.homepage     = "http://github.com/cj/scrivener"
+  s.license      = "MIT"
+
+  s.files = `git ls-files`.split("\n")
+
+  s.add_development_dependency "cutest"
+end

data/test/scrivener_test.rb

@@ -0,0 +1,317 @@
+require File.expand_path("../lib/scrivener", File.dirname(__FILE__))
+
+class A < Scrivener
+  attr_accessor :a
+  attr_accessor :b
+end
+
+scope do
+  test "ignore extra fields" do
+    atts = { :a => 1, :b => 2, :c => 3 }
+
+    filter = A.new(atts)
+
+    atts.delete(:c)
+
+    assert_equal atts, filter.attributes
+  end
+
+  test "not raise when there are less fields" do
+    atts = { :a => 1 }
+
+    assert filter = A.new(atts)
+    assert_equal filter.attributes, { :a => 1 }
+  end
+
+  test "return attributes" do
+    atts = { :a => 1, :b => 2 }
+
+    filter = A.new(atts)
+
+    assert_equal atts, filter.attributes
+  end
+
+  test "return only the required attributes" do
+    atts = { :a => 1, :b => 2 }
+
+    filter = A.new(atts)
+
+    assert_equal filter.slice(:a), { :a => 1 }
+  end
+end
+
+class B < Scrivener
+  attr_accessor :a
+  attr_accessor :b
+
+  def validate
+    assert_present :a
+    assert_present :b
+  end
+end
+
+scope do
+  test "validations" do
+    atts = { :a => 1, :b => 2 }
+
+    filter = B.new(atts)
+
+    assert filter.valid?
+  end
+
+  test "validation errors" do
+    atts = { :a => 1 }
+
+    filter = B.new(atts)
+
+    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 }
+
+    filter = B.new(atts)
+
+    filter.valid?
+    assert_equal atts, filter.attributes
+  end
+end
+
+class C
+  include Scrivener::Validations
+
+  attr_accessor :a
+
+  def validate
+    assert_present :a
+  end
+end
+
+scope do
+  test "validations without Scrivener" do
+    filter = C.new
+    filter.a = 1
+    assert filter.valid?
+
+    filter = C.new
+    assert_equal false, filter.valid?
+    assert_equal [:not_present], filter.errors[:a]
+  end
+end
+
+class D < Scrivener
+  attr_accessor :url, :email
+
+  def validate
+    assert_url :url
+    assert_email :email
+  end
+end
+
+scope do
+  test "email & url" do
+    filter = D.new({})
+
+    assert ! filter.valid?
+    assert_equal [:not_url],  filter.errors[:url]
+    assert_equal [:not_email],  filter.errors[:email]
+
+    filter = D.new(url: "google.com", email: "egoogle.com")
+
+    assert ! filter.valid?
+    assert_equal [:not_url],  filter.errors[:url]
+    assert_equal [:not_email],  filter.errors[:email]
+
+    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
+
+class E < Scrivener
+  attr_accessor :a
+
+  def validate
+    assert_length :a, 3..10
+  end
+end
+
+scope do
+  test "length validation" do
+    filter = E.new({})
+
+    assert ! filter.valid?
+    assert filter.errors[:a].include?(:not_in_range)
+
+    filter = E.new(a: "fo")
+    assert ! filter.valid?
+    assert filter.errors[:a].include?(:not_in_range)
+
+    filter = E.new(a: "foofoofoofo")
+    assert ! filter.valid?
+    assert filter.errors[:a].include?(:not_in_range)
+
+    filter = E.new(a: "foo")
+    assert filter.valid?
+  end
+end
+
+class F < Scrivener
+  attr_accessor :status
+
+  def validate
+    assert_member :status, %w{pending paid delivered}
+  end
+end
+
+scope do
+  test "member validation" do
+    filter = F.new({})
+    assert ! filter.valid?
+    assert_equal [:not_valid], filter.errors[:status]
+
+    filter = F.new(status: "foo")
+    assert ! filter.valid?
+    assert_equal [:not_valid], filter.errors[:status]
+
+    %w{pending paid delivered}.each do |status|
+      filter = F.new(status: status)
+      assert filter.valid?
+    end
+  end
+end
+
+class G < Scrivener
+  attr_accessor :a
+
+  def validate
+    assert_decimal :a
+  end
+end
+
+scope do
+  test "decimal validation" do
+    filter = G.new({})
+    assert ! filter.valid?
+    assert_equal [:not_decimal], filter.errors[:a]
+
+    %w{10 10.1 10.100000 0.100000 .1000 -10}.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
+
+class Thing < Scrivener
+  attribute :name
+  attribute :ends_on, Types::Date
+  attribute :price,   Types::Decimal
+
+  def validate
+    assert_present :ends_on
+  end
+end
+
+class OtherThing < Scrivener
+  attribute :foo, ->(val) { val.to_s.reverse }
+end
+
+scope do
+  test "casting to types" do
+    t = Thing.new(name: "Foo", ends_on: "2012-07-31", price: "20.45")
+
+    assert_equal "Foo",                 t.name
+    assert_equal Date.new(2012, 7, 31), t.ends_on
+    assert_equal BigDecimal("20.45"),   t.price
+  end
+
+  test "#attributes includes the parsed objects" do
+    t = Thing.new(name: "Foo", ends_on: "2012-07-31", price: "20.45")
+
+    assert_equal "Foo",                 t.attributes[:name]
+    assert_equal Date.new(2012, 7, 31), t.attributes[:ends_on]
+    assert_equal BigDecimal("20.45"),   t.attributes[:price]
+  end
+
+  test "casting with a proc" do
+    t = OtherThing.new(foo: "simple")
+    assert_equal "elpmis", t.foo
+  end
+
+  test "casting invalid values adds an error" do
+    t = Thing.new(ends_on: "this is not a date")
+
+    assert !t.valid?
+    assert_equal [:typecast], t.errors[:ends_on]
+    assert_equal "this is not a date", t.ends_on
+  end
+
+  test "accepts input with the correct type" do
+    t = Thing.new(name: "Foo", ends_on: Date.new(2012, 7, 31), price: BigDecimal("10.00"))
+    assert t.valid?
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: opal-scrivener
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Michel Martens
+- CJ Lazell
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-04-27 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
+  as a filter for whitelisted attributes.  Works with Opal.
+email:
+- michel@soveran.com
+- cjlazell@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".bundle/config"
+- ".gems"
+- ".gitignore"
+- AUTHORS
+- CHANGELOG.md
+- CONTRIBUTING
+- LICENSE
+- README.md
+- lib/opal-scrivener.rb
+- lib/scrivener.rb
+- lib/scrivener/types.rb
+- lib/scrivener/validations.rb
+- makefile
+- opal-scrivener.gemspec
+- test/scrivener_test.rb
+homepage: http://github.com/cj/scrivener
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+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.4.5.1
+signing_key: 
+specification_version: 4
+summary: Validation frontend for models.
+test_files: []