rom-model 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8dae3cb7ed3616ec2fb6dab8815cdcfcbcc5d4ee
+  data.tar.gz: dd5df2f70e0b945ec0a42e4ce02bbac700ca13ef
+SHA512:
+  metadata.gz: d9e16eedc459dfda4e4ff7d641179a23266781cbd646fedc10234386dfda320487dd30f2a81bf6134cca7b17ffa93c35a92e694872f91e1a91f2f4b6e924703f
+  data.tar.gz: 416b99d8c8bdcc6be0377706976e3d42b725f3b3f3136ffcc9f555fef2a34989fbe20a3a340cce8e980c43fc1e3e54b65ecf4a555f6ced6ba37bdfd1d1efcc6b

data/.gitignore

@@ -0,0 +1 @@
+Gemfile.lock

data/.rspec

@@ -0,0 +1,2 @@
+--color
+-r ./spec/spec_helper

data/.travis.yml

@@ -0,0 +1,30 @@
+language: ruby
+sudo: false
+cache: bundler
+bundler_args: --without yard guard benchmarks tools
+before_script:
+  - psql -c 'create database rom_model' -U postgres
+script: "bundle exec rake ci"
+rvm:
+  - 2.0
+  - 2.1
+  - 2.2
+  - rbx-2
+  - jruby
+  - jruby-head
+  - ruby-head
+env:
+  global:
+    - CODECLIMATE_REPO_TOKEN=TODO
+    - JRUBY_OPTS='--dev -J-Xmx1024M'
+matrix:
+  allow_failures:
+    - rvm: ruby-head
+    - rvm: jruby-head
+notifications:
+  webhooks:
+    urls:
+      - https://webhooks.gitter.im/e/39e1225f489f38b0bd09
+    on_success: change
+    on_failure: always
+    on_start: false

data/CHANGELOG.md

@@ -0,0 +1,3 @@
+# 0.1.0 2015-08-14
+
+Extracted code from rom-rails 0.5.0

data/Gemfile

@@ -0,0 +1,17 @@
+source 'https://rubygems.org'
+
+gemspec
+
+gem 'rom', github: 'rom-rb/rom', branch: 'master'
+gem 'rom-sql', github: 'rom-rb/rom-sql', branch: 'master'
+gem 'pg', platforms: [:mri, :rbx]
+gem 'pg_jruby', platforms: :jruby
+
+group :tools do
+  gem 'byebug', platforms: :mri
+end
+
+group :test do
+  gem 'rspec'
+  gem 'codeclimate-test-reporter', require: nil, platform: :rbx
+end

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2014-2015 Ruby Object Mapper
+
+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,65 @@
+[gem]: https://rubygems.org/gems/rom-model
+[travis]: https://travis-ci.org/rom-rb/rom-model
+[gemnasium]: https://gemnasium.com/rom-rb/rom-model
+[codeclimate]: https://codeclimate.com/github/rom-rb/rom-model
+[inchpages]: http://inch-ci.org/github/rom-rb/rom-model
+
+# ROM::Model
+
+[![Gem Version](https://badge.fury.io/rb/rom-model.svg)][gem]
+[![Build Status](https://travis-ci.org/rom-rb/rom-model.svg?branch=master)][travis]
+[![Dependency Status](https://gemnasium.com/rom-rb/rom-model.png)][gemnasium]
+[![Code Climate](https://codeclimate.com/github/rom-rb/rom-model/badges/gpa.svg)][codeclimate]
+[![Test Coverage](https://codeclimate.com/github/rom-rb/rom-model/badges/coverage.svg)][codeclimate]
+[![Inline docs](http://inch-ci.org/github/rom-rb/rom-model.svg?branch=master)][inchpages]
+
+This is a set of extensions for PORO objects to help in data coercion and validation.
+It was extracted from rom-rails and for now it uses Virtus and ActiveModel.
+
+The package includes:
+
+- `ROM::Attributes` for defining input attributes with types and coercion rules
+- `ROM::Validator` a standalone validator object extension built on top of
+  `ActiveModel::Validations` with additional features like nested validators
+
+## The Plan™
+
+This gem is built on top of existing 3rd party gems that have proven to be stable
+and good-enough. Unfortunatelly neither Virtus nor ActiveModel do not meet certain
+design requirements to be a good fit in the long term.
+
+For that reason we're exploring how to build a better foundation for rom-model.
+Specifically following initiatives are taking place:
+
+- Exploring a lower-level validation library with great composability features
+  and simple interface
+- Investigating a lower-level input data sanitization/coercion library that would
+  be a perfect fit for handling web forms and json input
+
+Furthermore rom-model will be soon extended with a third extension for defining
+[Algebraic Data Types](https://en.wikipedia.org/wiki/Algebraic_data_type) which
+will work remarkably well with [rom-repository](https://github.com/rom-rb/rom-repository)
+and its auto-mapping features.
+
+This project will provide convenient interfaces on top of robust lower-level tools
+and if it turns out to be too big we'll split it into smaller gems.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'rom-model'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install rom-model
+
+## License
+
+See `LICENSE` file.

data/Rakefile

@@ -0,0 +1,8 @@
+require "rspec/core/rake_task"
+require "rake/testtask"
+
+RSpec::Core::RakeTask.new(:spec)
+task default: [:ci]
+
+desc "Run CI tasks"
+task ci: [:spec]

data/config/locales/en.yml

@@ -0,0 +1,8 @@
+en:
+  activemodel:
+    errors:
+      models:
+        user:
+          attributes:
+            email:
+              taken: 'has already been taken'

data/lib/rom-model.rb

@@ -0,0 +1 @@
+require 'rom/model'

data/lib/rom/model.rb

@@ -0,0 +1,2 @@
+require 'rom/model/attributes'
+require 'rom/model/validator'

data/lib/rom/model/attributes.rb

@@ -0,0 +1,133 @@
+require 'virtus'
+require 'active_model' # can't cherry-pick conversion :(
+
+module ROM
+  module Model
+    # Mixin for validatable and coercible parameters
+    #
+    # @example
+    #
+    #   class UserAttributes
+    #     include ROM::Model::Attributes
+    #
+    #     attribute :email, String
+    #     attribute :age, Integer
+    #
+    #     validates :email, :age, presence: true
+    #   end
+    #
+    #   user_attrs = UserAttributes.new(email: '', age: '18')
+    #
+    #   user_attrs.email # => ''
+    #   user_attrs.age # => 18
+    #
+    #   user_attrs.valid? # => false
+    #   user_attrs.errors # => #<ActiveModel::Errors:0x007fd2423fadb0 ...>
+    #
+    # @api public
+    module Attributes
+      VirtusModel = Virtus.model(nullify_blank: true)
+
+      # Inclusion hook used to extend a class with required interfaces
+      #
+      # @api private
+      def self.included(base)
+        base.class_eval do
+          include VirtusModel
+          include ActiveModel::Conversion
+        end
+        base.extend(ClassMethods)
+      end
+
+      # Return model name for the attributes class
+      #
+      # The model name object is configurable using `set_model_name` macro
+      #
+      # @see ClassMethods#set_model_name
+      #
+      # @return [ActiveModel::Name]
+      #
+      # @api public
+      def model_name
+        self.class.model_name
+      end
+
+      # Class extensions for an attributes class
+      #
+      # @api public
+      module ClassMethods
+        # Default timestamp attribute names used by `timestamps` method
+        DEFAULT_TIMESTAMPS = [:created_at, :updated_at].freeze
+
+        # Process input and return attributes instance
+        #
+        # @example
+        #   class UserAttributes
+        #     include ROM::Model::Attributes
+        #
+        #     attribute :name, String
+        #   end
+        #
+        #   UserAttributes[name: 'Jane']
+        #
+        # @param [Hash,#to_hash] input The input params
+        #
+        # @return [Attributes]
+        #
+        # @api public
+        def [](input)
+          input.is_a?(self) ? input : new(input)
+        end
+
+        # Macro for defining ActiveModel::Name object on the attributes class
+        #
+        # This is essential for rails helpers to work properly when generating
+        # form input names etc.
+        #
+        # @example
+        #   class UserAttributes
+        #     include ROM::Model::Attributes
+        #
+        #     set_model_name 'User'
+        #   end
+        #
+        # @return [undefined]
+        #
+        # @api public
+        def set_model_name(name)
+          class_eval <<-RUBY
+            def self.model_name
+              @model_name ||= ActiveModel::Name.new(self, nil, #{name.inspect})
+            end
+          RUBY
+        end
+
+        # Shortcut for defining timestamp attributes like created_at etc.
+        #
+        # @example
+        #   class NewPostAttributes
+        #     include ROM::Model::Attributes
+        #
+        #     # provide name(s) explicitly
+        #     timestamps :published_at
+        #
+        #     # defaults to :created_at, :updated_at without args
+        #     timestamps
+        #   end
+        #
+        # @api public
+        def timestamps(*attrs)
+          if attrs.empty?
+            DEFAULT_TIMESTAMPS.each do |t|
+              attribute t, DateTime, default: proc { DateTime.now }
+            end
+          else
+            attrs.each do |attr|
+              attribute attr, DateTime, default: proc { DateTime.now }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/model/validator.rb

@@ -0,0 +1,201 @@
+require 'charlatan'
+
+require 'rom/support/constants'
+require 'rom/constants'
+
+require 'rom/model/validator/uniqueness_validator'
+require 'rom/support/class_macros'
+
+module ROM
+  module Model
+    class ValidationError < CommandError
+      include Charlatan.new(:errors)
+      include Equalizer.new(:errors)
+    end
+
+    # Mixin for ROM-compliant validator objects
+    #
+    # @example
+    #
+    #
+    #   class UserAttributes
+    #     include ROM::Model::Attributes
+    #
+    #     attribute :name
+    #
+    #     validates :name, presence: true
+    #   end
+    #
+    #   class UserValidator
+    #     include ROM::Model::Validator
+    #   end
+    #
+    #   attrs = UserAttributes.new(name: '')
+    #   UserValidator.call(attrs) # raises ValidationError
+    #
+    # @api public
+    module Validator
+      # Inclusion hook that extends a class with required interfaces
+      #
+      # @api private
+      def self.included(base)
+        base.class_eval do
+          extend ClassMethods
+          extend ROM::ClassMacros
+
+          include ActiveModel::Validations
+          include Equalizer.new(:attributes, :errors)
+
+          base.defines :embedded_validators
+
+          embedded_validators({})
+        end
+      end
+
+      # @return [Model::Attributes]
+      #
+      # @api private
+      attr_reader :attributes
+
+      # @api private
+      attr_reader :attr_names
+
+      delegate :model_name, to: :attributes
+
+      # @api private
+      def initialize(attributes)
+        @attributes = attributes
+        @attr_names = self.class.validators.map(&:attributes).flatten.uniq
+      end
+
+      # @return [Model::Attributes]
+      #
+      # @api public
+      def to_model
+        attributes
+      end
+
+      # Trigger validations and return attributes on success
+      #
+      # @raises ValidationError
+      #
+      # @return [Model::Attributes]
+      #
+      # @api public
+      def call
+        raise ValidationError, errors unless valid?
+        attributes
+      end
+
+      private
+
+      # This is needed for ActiveModel::Validations to work properly
+      # as it expects the object to provide attribute values. Meh.
+      #
+      # @api private
+      def method_missing(name, *args, &block)
+        if attr_names.include?(name)
+          attributes[name]
+        else
+          super
+        end
+      end
+
+      module ClassMethods
+        # Set relation name for a validator
+        #
+        # This is needed for validators that require database access
+        #
+        # @example
+        #
+        #   class UserValidator
+        #     include ROM::Model::Validator
+        #
+        #     relation :users
+        #
+        #     validates :name, uniqueness: true
+        #   end
+        #
+        # @return [Symbol]
+        #
+        # @api public
+        def relation(name = nil)
+          @relation = name if name
+          @relation
+        end
+
+        # @api private
+        def set_model_name(name)
+          class_eval <<-RUBY
+            def self.model_name
+              @model_name ||= ActiveModel::Name.new(self, nil, #{name.inspect})
+            end
+          RUBY
+        end
+
+        # Trigger validation for specific attributes
+        #
+        # @param [Model::Attributes] attributes The attributes for validation
+        #
+        # @raises [ValidationError]
+        #
+        # @return [Model::Attributes]
+        def call(attributes)
+          validator = new(attributes)
+          validator.call
+        end
+
+        # Specify an embedded validator for nested structures
+        #
+        # @example
+        #   class UserValidator
+        #     include ROM::Model::Validator
+        #
+        #     set_model_name 'User'
+        #
+        #     embedded :address do
+        #       validates :city, :street, :zipcode, presence: true
+        #     end
+        #
+        #     emebdded :tasks do
+        #       validates :title, presence: true
+        #     end
+        #   end
+        #
+        #   validator = UserAttributes.new(address: {}, tasks: {})
+        #
+        #   validator.valid? # false
+        #   validator.errors[:address].first # errors for address
+        #   validator.errors[:tasks] # errors for tasks
+        #
+        # @api public
+        def embedded(name, &block)
+          validator_class = Class.new { include ROM::Model::Validator }
+          validator_class.class_eval(&block)
+          validator_class.set_model_name(name.to_s.classify)
+
+          embedded_validators[name] = validator_class
+
+          validates name, presence: true
+
+          validate do
+            value = attributes[name]
+
+            if value.present?
+              Array([value]).flatten.each do |object|
+                validator = validator_class.new(object)
+                validator.validate
+
+                if validator.errors.any?
+                  errors.add(name, validator.errors)
+                else
+                  errors.add(name, [])
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rom/model/validator/uniqueness_validator.rb

@@ -0,0 +1,83 @@
+require 'active_model/validator'
+
+module ROM
+  module Model
+    module Validator
+      # Uniqueness validation
+      #
+      # @api public
+      class UniquenessValidator < ActiveModel::EachValidator
+        # Relation validator class
+        #
+        # @api private
+        attr_reader :klass
+
+        # error message
+        #
+        # @return [String, Symbol]
+        #
+        # @api private
+        attr_reader :message
+
+        # @api private
+        def initialize(options)
+          super
+          @klass = options.fetch(:class)
+          @message = options.fetch(:message) { :taken }
+          @scope_keys = options[:scope]
+        end
+
+        # Hook called by ActiveModel internally
+        #
+        # @api private
+        def validate_each(validator, name, value)
+          scope = Array(@scope_keys).each_with_object({}) do |key, scope|
+            scope[key] = validator.to_model[key]
+          end
+          validator.errors.add(name, message) unless unique?(name, value, scope)
+        end
+
+        private
+
+        # Get relation object from the rom env
+        #
+        # @api private
+        def relation
+          if relation_name
+            rom.relations[relation_name]
+          else
+            raise "relation must be specified to use uniqueness validation"
+          end
+        end
+
+        # Relation name defined on the validator class
+        #
+        # @api private
+        def relation_name
+          klass.relation
+        end
+
+        # Shortcut to access global rom env
+        #
+        # @return [ROM::Env]
+        #
+        # @api private
+        def rom
+          ROM.env
+        end
+
+        # Ask relation if a given attribute value is unique
+        #
+        # This uses `Relation#unique?` interface that not all adapters can
+        # implement.
+        #
+        # @return [TrueClass,FalseClass]
+        #
+        # @api private
+        def unique?(name, value, scope)
+          relation.unique?({name => value}.merge(scope))
+        end
+      end
+    end
+  end
+end

data/lib/rom/model/version.rb

@@ -0,0 +1,5 @@
+module ROM
+  module Model
+    VERSION = '0.1.0'.freeze
+  end
+end

data/rakelib/mutant.rake

@@ -0,0 +1,16 @@
+desc "Run mutant against a specific subject"
+task :mutant do
+  subject = ARGV.last
+  if subject == 'mutant'
+    abort "usage: rake mutant SUBJECT\nexample: rake mutant ROM::Header"
+  else
+    opts = {
+      'include' => 'lib',
+      'require' => 'rom',
+      'use' => 'rspec',
+      'ignore-subject' => "#{subject}#respond_to_missing?"
+    }.to_a.map { |k, v| "--#{k} #{v}" }.join(' ')
+
+    exec("bundle exec mutant #{opts} #{subject}")
+  end
+end

data/rakelib/rubocop.rake

@@ -0,0 +1,18 @@
+begin
+  require "rubocop/rake_task"
+
+  Rake::Task[:default].enhance [:rubocop]
+
+  RuboCop::RakeTask.new do |task|
+    task.options << "--display-cop-names"
+  end
+
+  namespace :rubocop do
+    desc 'Generate a configuration file acting as a TODO list.'
+    task :auto_gen_config do
+      exec "bundle exec rubocop --auto-gen-config"
+    end
+  end
+
+rescue LoadError
+end

data/rom-model.gemspec

@@ -0,0 +1,29 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rom/model/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rom-model"
+  spec.version       = ROM::Model::VERSION.dup
+  spec.authors       = ["Piotr Solnica"]
+  spec.email         = ["piotr.solnica@gmail.com"]
+  spec.summary       = 'A small collection of extensions useful for data coercion and validation'
+  spec.homepage      = "http://rom-rb.org"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_runtime_dependency 'rom-support', '~> 0.1'
+  spec.add_runtime_dependency 'charlatan', '~> 0.1'
+  spec.add_runtime_dependency 'virtus', '~> 1.0', '>= 1.0.5'
+  spec.add_runtime_dependency 'activemodel', '>= 3.0', '< 5.0'
+  spec.add_runtime_dependency 'i18n'
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rubocop", "~> 0.28.0"
+end

data/spec/shared/database.rb

@@ -0,0 +1,32 @@
+shared_context 'database' do
+  let(:rom) { ROM.env }
+  let(:uri) { DB_URI }
+  let(:conn) { Sequel.connect(uri) }
+
+  def drop_tables
+    [:users].each do |name|
+      conn.drop_table?(name)
+    end
+  end
+
+  before do
+    setup = ROM.setup(:sql, conn)
+
+    drop_tables
+
+    conn.create_table :users do
+      primary_key :id
+      column :name, String, null: false
+      column :email, String, null: false
+      column :birthday, Date
+      index :name, unique: true
+      check { char_length(name) > 2 }
+    end
+
+    setup.relation(:users)
+  end
+
+  after do
+    conn.disconnect
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,32 @@
+if RUBY_ENGINE == 'rbx'
+  require "codeclimate-test-reporter"
+  CodeClimate::TestReporter.start
+end
+
+require 'rom-model'
+require 'rom-sql'
+
+begin
+  require 'byebug'
+rescue LoadError
+end
+
+DB_URI = ENV.fetch('DB_URI', 'postgres://localhost/rom_model')
+
+root = Pathname(__FILE__).dirname
+
+Dir[root.join('support/*.rb').to_s].each do |f|
+  require f
+end
+
+Dir[root.join('shared/*.rb').to_s].each do |f|
+  require f
+end
+
+I18n.load_path << [root.join('../config/locales/en.yml').realpath]
+
+RSpec.configure do |config|
+  config.order = "random"
+end
+
+ROM.use :auto_registration

data/spec/unit/attributes_spec.rb

@@ -0,0 +1,46 @@
+describe ROM::Model::Attributes do
+  let(:attributes) do
+    Class.new do
+      include ROM::Model::Attributes
+
+      attribute :name, String
+
+      timestamps
+    end
+  end
+
+  describe '.timestamps' do
+    it 'provides a way to specify timestamps with default values' do
+      expect(attributes.new.created_at).to be_a(DateTime)
+      expect(attributes.new.updated_at).to be_a(DateTime)
+    end
+
+    context 'passing in arbritrary names' do
+      it 'excludes :created_at when passing in :updated_at' do
+        attributes = Class.new {
+          include ROM::Model::Attributes
+
+          timestamps(:updated_at)
+        }
+
+        model = attributes.new
+
+        expect(model).not_to respond_to(:created_at)
+        expect(model).to respond_to(:updated_at)
+      end
+
+      it 'accepts multiple timestamp attribute names' do
+        attributes = Class.new {
+          include ROM::Model::Attributes
+
+          timestamps(:published_at, :revised_at)
+        }
+
+        model = attributes.new
+
+        expect(model).to respond_to(:published_at)
+        expect(model).to respond_to(:revised_at)
+      end
+    end
+  end
+end

data/spec/unit/validator/embedded_spec.rb

@@ -0,0 +1,116 @@
+describe 'Embedded validators' do
+  it 'allows defining a validator for a nested hash' do
+    user_validator = Class.new do
+      include ROM::Model::Validator
+
+      set_model_name 'User'
+
+      validates :name, presence: true
+
+      embedded :address do
+        set_model_name 'Address'
+
+        validates :street, :city, :zipcode, presence: true
+      end
+    end
+
+    attributes = { name: '', address: { street: '', city: '', zipcode: '' } }
+
+    expect { user_validator.call(attributes) }.to raise_error(
+      ROM::Model::ValidationError)
+
+    validator = user_validator.new(attributes)
+
+    expect(validator).to_not be_valid
+
+    expect(validator.errors[:name]).to include("can't be blank")
+
+    address_errors = validator.errors[:address].first
+
+    expect(address_errors).to_not be_empty
+
+    expect(address_errors[:street]).to include("can't be blank")
+    expect(address_errors[:city]).to include("can't be blank")
+    expect(address_errors[:zipcode]).to include("can't be blank")
+  end
+
+  it 'allows defining a validator for a nested array' do
+    user_validator = Class.new do
+      include ROM::Model::Validator
+
+      set_model_name 'User'
+
+      validates :name, presence: true
+
+      embedded :tasks do
+        set_model_name 'Task'
+
+        validates :title, presence: true
+      end
+    end
+
+    attributes = {
+      name: '',
+      tasks: [
+        { title: '' },
+        { title: 'Two' }
+      ]
+    }
+
+    expect { user_validator.call(attributes) }.to raise_error(
+      ROM::Model::ValidationError)
+
+    validator = user_validator.new(attributes)
+
+    expect(validator).to_not be_valid
+
+    expect(validator.errors[:name]).to include("can't be blank")
+
+    task_errors = validator.errors[:tasks]
+
+    expect(task_errors).to_not be_empty
+
+    expect(task_errors[0][:title]).to include("can't be blank")
+    expect(task_errors[1]).to be_empty
+  end
+
+  it 'validates presence of the nested structure' do
+    user_validator = Class.new do
+      include ROM::Model::Validator
+
+      set_model_name 'User'
+
+      validates :name, presence: true
+
+      embedded :tasks do
+        set_model_name 'Task'
+
+        validates :title, presence: true
+      end
+    end
+
+    validator = user_validator.new(name: '')
+    validator.validate
+
+    expect(validator.errors[:name]).to include("can't be blank")
+    expect(validator.errors[:tasks]).to include("can't be blank")
+  end
+
+  it 'exposes registered validators in embedded_validators hash' do
+    user_validator = Class.new do
+      include ROM::Model::Validator
+
+      set_model_name 'User'
+
+      validates :name, presence: true
+
+      embedded :tasks do
+        set_model_name 'Task'
+
+        validates :title, presence: true
+      end
+    end
+
+    expect(user_validator.embedded_validators[:tasks]).to be_present
+  end
+end

data/spec/unit/validator_spec.rb

@@ -0,0 +1,165 @@
+describe 'Validation' do
+  include_context 'database'
+
+  subject(:validator) { user_validator.new(attributes) }
+
+  let(:user_attrs) do
+    Class.new {
+      include ROM::Model::Attributes
+
+      set_model_name 'User'
+
+      attribute :name, String
+      attribute :email, String
+      attribute :birthday, Date
+    }
+  end
+
+  let(:user_validator) do
+    Class.new {
+      include ROM::Model::Validator
+
+      relation :users
+
+      validates :name, presence: true, uniqueness: { message: 'TAKEN!' }
+      validates :email, uniqueness: true
+
+      def self.name
+        'User'
+      end
+    }
+  end
+
+  before { ROM.finalize }
+
+  describe '#call' do
+    let(:attributes) { user_attrs.new }
+
+    it 'raises validation error when attributes are not valid' do
+      expect { validator.call }.to raise_error(ROM::Model::ValidationError)
+    end
+  end
+
+  describe "#validate" do
+    let(:attributes) { user_attrs.new }
+
+    it "sets errors when attributes are not valid" do
+      validator.validate
+      expect(validator.errors[:name]).to eql(["can't be blank"])
+    end
+  end
+
+  describe ':presence' do
+    let(:attributes) { user_attrs.new(name: '') }
+
+    it 'sets error messages' do
+      expect(validator).to_not be_valid
+      expect(validator.errors[:name]).to eql(["can't be blank"])
+    end
+  end
+
+  describe ':uniqueness' do
+    let(:attributes) { user_attrs.new(name: 'Jane', email: 'jane@doe.org') }
+
+    it 'sets default error messages' do
+      rom.relations.users.insert(name: 'Jane', email: 'jane@doe.org')
+
+      expect(validator).to_not be_valid
+      expect(validator.errors[:email]).to eql(['has already been taken'])
+    end
+
+    it 'sets custom error messages' do
+      rom.relations.users.insert(name: 'Jane', email: 'jane@doe.org')
+
+      expect(validator).to_not be_valid
+      expect(validator.errors[:name]).to eql(['TAKEN!'])
+    end
+
+    context 'with unique attributes within a scope' do
+      let(:user_validator) do
+        Class.new {
+          include ROM::Model::Validator
+
+          relation :users
+
+          validates :email, uniqueness: {scope: :name}
+
+          def self.name
+            'User'
+          end
+        }
+      end
+
+      let(:doubly_scoped_validator) do
+        Class.new {
+          include ROM::Model::Validator
+
+          relation :users
+
+          validates :email, uniqueness: {scope: [:name, :birthday]}
+
+          def self.name
+            'User'
+          end
+        }
+      end
+
+      it 'does not add errors' do
+        rom.relations.users.insert(name: 'Jane', email: 'jane+doe@doe.org')
+        attributes = user_attrs.new(name: 'Jane', email: 'jane@doe.org', birthday: Date.parse('2014-12-12'))
+        validator = user_validator.new(attributes)
+        expect(validator).to be_valid
+      end
+
+      it 'adds an error when the doubly scoped validation fails' do
+        attributes = user_attrs.new(name: 'Jane', email: 'jane@doe.org', birthday: Date.parse('2014-12-12'))
+        validator = doubly_scoped_validator.new(attributes)
+        expect(validator).to be_valid
+
+        rom.relations.users.insert(attributes.attributes)
+        expect(validator).to_not be_valid
+
+        attributes = user_attrs.new(name: 'Jane', email: 'jane+doe@doe.org', birthday: Date.parse('2014-12-12'))
+        validator = doubly_scoped_validator.new(attributes)
+        expect(validator).to be_valid
+      end
+    end
+
+    describe 'with missing relation' do
+      let(:user_validator) do
+        Class.new {
+          include ROM::Model::Validator
+
+          validates :email, uniqueness: true
+
+          def self.name
+            'User'
+          end
+        }
+      end
+
+      it 'raises a helpful error' do
+        validator = user_validator.new(user_attrs.new)
+        expect {
+          validator.valid?
+        }.to raise_error(/relation must be specified/)
+      end
+    end
+  end
+
+  describe '#method_missing' do
+    let(:attributes) { { name: 'Jane' } }
+
+    it 'returns attribute value if present' do
+      expect(validator.name).to eql('Jane')
+    end
+
+    it 'returns nil if attribute is not present' do
+      expect(validator.email).to be(nil)
+    end
+
+    it 'raises error when name does not match any of the attributes' do
+      expect { validator.foobar }.to raise_error(NoMethodError, /foobar/)
+    end
+  end
+end

metadata

@@ -0,0 +1,196 @@
+--- !ruby/object:Gem::Specification
+name: rom-model
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Piotr Solnica
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-14 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rom-support
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: charlatan
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: virtus
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.5
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.0'
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: i18n
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  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'
+- !ruby/object:Gem::Dependency
+  name: rake
+  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'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.28.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.28.0
+description: 
+email:
+- piotr.solnica@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CHANGELOG.md
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- config/locales/en.yml
+- lib/rom-model.rb
+- lib/rom/model.rb
+- lib/rom/model/attributes.rb
+- lib/rom/model/validator.rb
+- lib/rom/model/validator/uniqueness_validator.rb
+- lib/rom/model/version.rb
+- rakelib/mutant.rake
+- rakelib/rubocop.rake
+- rom-model.gemspec
+- spec/shared/database.rb
+- spec/spec_helper.rb
+- spec/unit/attributes_spec.rb
+- spec/unit/validator/embedded_spec.rb
+- spec/unit/validator_spec.rb
+homepage: http://rom-rb.org
+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
+signing_key: 
+specification_version: 4
+summary: A small collection of extensions useful for data coercion and validation
+test_files:
+- spec/shared/database.rb
+- spec/spec_helper.rb
+- spec/unit/attributes_spec.rb
+- spec/unit/validator/embedded_spec.rb
+- spec/unit/validator_spec.rb