validation_delegation 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZmMyYTIyMzkzMDI5ZDU0MDQ4OWEwNGI5MzNhNzdlMGExOWE1MGJkZg==
+  data.tar.gz: !binary |-
+    ZTZkZjMzZjFmMjIwM2M1NDc0OTAwYjliNThiZWQ2Y2YzYmQ3NjBkYw==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    YjFkYTc0Yzk3OWVhYjIwOGQ1MDVkZjRiMGM5OGJiYmM2ZjNjNTk5MGZjNTNi
+    Mzc2YjMxN2UwMjQ3NDY2N2E5OWZlNGJkYjQ2ZmUxMjU5M2NiYTM3ZDlhYTIx
+    M2Q4MjFiZTlkMzE0NmU5NWNmOGNjM2FjYzRjNGI1YTIwYTZiYzY=
+  data.tar.gz: !binary |-
+    NDE4ZjRjNGYwNWQ2ODk1NDFmOTc2Y2QxY2E1Y2IyZDc2OGVlYzQ3MTRjYWEy
+    ZDM5NTQxYTBmOGM3ZTBhZDljZDlhMGRmMjNhYjMyMTcyNjliMzUyZTBmZTU0
+    MWJiOTM3MjdjODA2MGZjY2I5NDY5MjMxMjI1OGNiN2QyYmIxYzE=

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in validation_delegation.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Ben Eddy
+
+MIT License
+
+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,175 @@
+# Validation Delegation
+
+Validation delegation allows an object to proxy validations to other objects. This facilitates [composition](http://en.wikipedia.org/wiki/Object_composition) and prevents the duplication of validation logic.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'validation_delegation'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install validation_delegation
+
+## Usage
+
+An example use case for validation delegation is a `SignUp` object which simultaneously creates a `User` and an `Organization`. The `SignUp` object is only valid if both the user and organization are valid.
+
+```Ruby
+class User < ActiveRecord::Base
+  validates :email, presence: true
+end
+
+class Organization < ActiveRecord::Base
+  validates :name, presence: true
+end
+
+class SignUp
+  include ActiveModel::Validations
+
+  # delegate validation to the user
+  delegate_validation to: :user
+
+  # and also delegate validation to the organization
+  delegate_validation to: :organization
+
+  attr_reader :user, :organization
+
+  def initialize
+    @user = user
+    @organization = organization
+  end
+
+  def email=(email)
+    @user.email = email
+  end
+
+  def name=(name)
+    @organization.name = name
+  end
+end
+```
+
+Assigning invalid user and organization attributes, which are in turn assigned to the `@user` and `@organization` instance variables, invalidates the `SignUp`, and faithfully copies the user and organization errors.
+
+```Ruby
+signup = SignUp.new
+signup.email = ""
+signup.name = ""
+
+signup.valid?
+# => false
+
+signup.errors.full_messages
+# => ["email can't be blank", "name can't be blank"]
+
+```
+
+```Ruby
+signup.email = "email@example.com"
+signup.name = "My Organization"
+
+signup.valid?
+
+```
+
+If you do not want to copy errors directly onto the composing object, you can specify to which attribute the errors should apply. In this case, we copy errors onto the "organization" attribute. This is useful for nesting forms via `fields_for`.
+
+```Ruby
+class SignUp
+  include ActiveModel::Model
+
+  delegate_validation :organization, to: :organization
+
+  attr_reader :organization
+
+  def initialize
+    @organization = Organization.new
+  end
+
+  def name=(name)
+    @organization.name = name
+  end
+end
+
+signup = SignUp.new
+signup.name = ""
+signup.valid?
+# => false
+
+signup.errors.full_messages
+# => ["organization name can't be blank"]
+```
+
+### Options
+
+`delegate_validation` accepts several options.
+
+- `:if` - errors are only copied if the method specified by the `:if` option returns true
+
+```Ruby
+class SignUp
+  delegate_validation to: :user, if: :validate_user?
+
+  def validate_user?
+    # logic
+  end
+end
+```
+
+- `:unless` - errors are only copied if the method specified by the `:unless` option returns false
+
+```Ruby
+class SignUp
+  delegate_validation to: :user, unless: :skip_validation?
+
+  def skip_validation?
+    # logic
+  end
+end
+```
+
+- `:only` - a whitelist of errors to be copied
+
+```Ruby
+class SignUp
+  delegate_validation to: :user, only: :email
+end
+
+signup = SignUp.new
+signup.user.errors.add(:email, :required)
+signup.user.errors.add(:phone_number, :required)
+
+signup.valid?
+signup.errors.full_messages
+# => ["email can't be blank"]
+```
+
+- `:except` - a blacklist of errors to be copied
+
+```Ruby
+class SignUp
+  delegate_validation to: :user, except: :email
+end
+
+signup = SignUp.new
+signup.user.errors.add(:email, :required)
+signup.user.errors.add(:phone_number, :required)
+
+signup.valid?
+signup.errors.full_messages
+# => ["phone number can't be blank"]
+```
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/lib/validation_delegation/version.rb

@@ -0,0 +1,3 @@
+module ValidationDelegation
+  VERSION = "0.0.1"
+end

data/lib/validation_delegation.rb

@@ -0,0 +1,82 @@
+require "validation_delegation/version"
+require "active_support"
+require "active_support/core_ext"
+
+module ValidationDelegation
+  def self.included(base)
+    base.send(:extend, ClassMethods)
+  end
+
+  def receive_errors(attribute, object_attribute, errors)
+    Array.wrap(errors).each{ |error| receive_error attribute, object_attribute, error }
+  end
+
+  def receive_error(attribute, object_attribute, error)
+    attribute ? receive_error_on_attribute(attribute, object_attribute, error) : receive_error_on_self(object_attribute, error)
+  end
+
+  def receive_error_on_attribute(attribute, prefix, error)
+    errors[attribute] << [format_attribute(prefix), error].join(" ")
+  end
+
+  def receive_error_on_self(attribute, error)
+    errors[attribute] << error
+  end
+
+  def format_attribute(attribute_name)
+    attribute_name.to_s.humanize.downcase.gsub(/\./, " ")
+  end
+
+  module ClassMethods
+    def delegate_validation(*args)
+      if args.first.is_a?(Hash)
+        transplant_errors(args.first)
+      else
+        transplant_errors(args.last.merge(attribute: args.first))
+      end
+    end
+
+    def transplant_errors(options)
+      validate do
+        return unless send(options[:if]) if options[:if]
+        return if send(options[:unless]) if options[:unless]
+
+        object = send(options[:to])
+        ErrorTransplanter.new(self, object, options).transplant unless object.valid?
+      end
+    end
+  end
+
+  class ErrorTransplanter
+    delegate :errors, to: :donor
+    delegate :receive_errors, to: :recipient
+
+    attr_accessor :recipient, :donor, :options
+
+    def initialize(recipient, donor, options)
+      self.recipient = recipient
+      self.donor     = donor
+      self.options   = options
+    end
+
+    def transplant
+      errors.each do |object_attribute, object_errors|
+        next if ignore_attribute? object_attribute
+        receive_errors options[:attribute], object_attribute, object_errors
+      end
+    end
+
+    def ignore_attribute?(attribute)
+      excepted_attribute?(attribute) || !specified_attribute?(attribute)
+    end
+
+    def excepted_attribute?(attribute)
+      Array.wrap(options[:except]).include?(attribute.to_sym)
+    end
+
+    def specified_attribute?(attribute)
+      return true unless options[:only]
+      Array.wrap(options[:only]).include?(attribute.to_sym)
+    end
+  end
+end

data/spec/validation_delegation_spec.rb

@@ -0,0 +1,147 @@
+require "active_model"
+require "validation_delegation"
+
+class TestClass ; end
+
+class Validator
+  include ActiveModel::Validations
+end
+
+RSpec::Matchers.define :have_error do |message|
+  match do |actual|
+    actual.errors[@attribute].include?(message)
+  end
+
+  chain :on do |attribute|
+    @attribute = attribute
+  end
+end
+
+describe ValidationDelegation do
+  let(:validator) { Validator.new }
+  let(:test) { TestClass.new }
+
+  before do
+    Object.send(:remove_const, "TestClass")
+
+    class TestClass
+      include ActiveModel::Validations
+      include ValidationDelegation
+    end
+
+    allow(validator).to receive(:valid?).and_return(false)
+    validator.errors[:attr] << "is invalid"
+    allow(test).to receive(:validator).and_return(validator)
+  end
+
+  subject { test.tap(&:valid?) }
+
+  it "copies errors from the validator to itself" do
+    TestClass.delegate_validation to: :validator
+    expect(subject).to have_error("is invalid").on(:attr)
+  end
+
+  it "copies all errors" do
+    validator.errors[:attr] << "is bananas"
+    TestClass.delegate_validation to: :validator
+
+    expect(subject).to have_error("is invalid").on(:attr)
+    expect(subject).to have_error("is bananas").on(:attr)
+  end
+
+  it "copies errors if the :if option is true" do
+    allow(test).to receive(:validate?).and_return(true)
+    TestClass.delegate_validation to: :validator, if: :validate?
+    expect(subject).to have_error("is invalid").on(:attr)
+  end
+
+  it "does not copy errors if the :if option is false" do
+    allow(test).to receive(:validate?).and_return(false)
+    TestClass.delegate_validation to: :validator, if: :validate?
+    expect(subject).to_not have_error("is invalid").on(:attr)
+  end
+
+  it "copies errors if the :unless option is false" do
+    allow(test).to receive(:validate?).and_return(false)
+    TestClass.delegate_validation to: :validator, unless: :validate?
+    expect(subject).to have_error("is invalid").on(:attr)
+  end
+
+  it "does not copy errors if the :unless option is true" do
+    allow(test).to receive(:validate?).and_return(true)
+    TestClass.delegate_validation to: :validator, unless: :validate?
+    expect(subject).to_not have_error("is invalid").on(:attr)
+  end
+
+  it "does not copy errors for excluded attributes" do
+    allow(test).to receive(:validate?).and_return(true)
+    TestClass.delegate_validation to: :validator, except: :attr
+    expect(subject).to_not have_error("is invalid").on(:attr)
+  end
+
+  it "only copies errors for specified attributes" do
+    allow(test).to receive(:validate?).and_return(true)
+    TestClass.delegate_validation to: :validator, only: :attr
+    expect(subject).to have_error("is invalid").on(:attr)
+  end
+
+  context "an method is supplied" do
+    it "copies errors to the specified method and prefixes the attribute name" do
+      TestClass.delegate_validation :my_method, to: :validator
+      expect(subject).to have_error("attr is invalid").on(:my_method)
+    end
+
+    it "copies all errors" do
+      allow(validator).to receive(:errors).and_return({attr: ["is invalid", "is bananas"]})
+      TestClass.delegate_validation :my_method, to: :validator
+
+      expect(subject).to have_error("attr is invalid").on(:my_method)
+      expect(subject).to have_error("attr is bananas").on(:my_method)
+    end
+
+    it "reformats nested attribute errors" do
+      TestClass.delegate_validation :my_method, to: :validator
+      validator.errors[:"associated_class.attribute"] << "is bananas"
+
+      expect(subject).to have_error("associated class attribute is bananas").on(:my_method)
+    end
+
+    it "copies errors if the :if option is true" do
+      allow(test).to receive(:validate?).and_return(true)
+      TestClass.delegate_validation :my_method, to: :validator, if: :validate?
+
+      expect(subject).to have_error("attr is invalid").on(:my_method)
+    end
+
+    it "does not copy errors if the :if option is false" do
+      allow(test).to receive(:validate?).and_return(false)
+      TestClass.delegate_validation :my_method, to: :validator, if: :validate?
+      expect(subject).to_not have_error("attr is invalid").on(:my_method)
+    end
+
+    it "copies errors if the :unless option is false" do
+      allow(test).to receive(:validate?).and_return(false)
+      TestClass.delegate_validation :my_method, to: :validator, unless: :validate?
+      expect(subject).to have_error("attr is invalid").on(:my_method)
+    end
+
+    it "does not copy errors if the :unless option is true" do
+      allow(test).to receive(:validate?).and_return(true)
+      TestClass.delegate_validation :my_method, to: :validator, unless: :validate?
+      expect(subject).to_not have_error("attr is invalid").on(:my_method)
+    end
+
+    it "does not copy errors for excluded attributes" do
+      allow(test).to receive(:validate?).and_return(true)
+      TestClass.delegate_validation :my_method, to: :validator, except: :attr
+      expect(subject).to_not have_error("attr is invalid").on(:my_method)
+    end
+
+    it "only copies errors for specified attributes" do
+      allow(test).to receive(:validate?).and_return(true)
+      TestClass.delegate_validation :my_method, to: :validator, only: :attr
+      expect(subject).to have_error("attr is invalid").on(:my_method)
+    end
+  end
+
+end

data/validation_delegation.gemspec

@@ -0,0 +1,28 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require "validation_delegation/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "validation_delegation"
+  spec.version       = ValidationDelegation::VERSION
+  spec.authors       = ["Ben Eddy"]
+  spec.email         = ["bae@foraker.com"]
+  spec.description   = %q{Delegates validation between objects}
+  spec.summary       = %q{Validation delegation allows an object to proxy validations to other objects. This facilitates composition and prevents the duplication of validation logic.}
+  spec.homepage      = "https://github.com/foraker/validation_delegation"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  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_dependency "activesupport", "~> 3.1"
+  spec.add_dependency "activemodel", "~> 3.1"
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

metadata

@@ -0,0 +1,126 @@
+--- !ruby/object:Gem::Specification
+name: validation_delegation
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Ben Eddy
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: activemodel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !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: rspec
+  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: Delegates validation between objects
+email:
+- bae@foraker.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/validation_delegation.rb
+- lib/validation_delegation/version.rb
+- spec/validation_delegation_spec.rb
+- validation_delegation.gemspec
+homepage: https://github.com/foraker/validation_delegation
+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.0.3
+signing_key: 
+specification_version: 4
+summary: Validation delegation allows an object to proxy validations to other objects.
+  This facilitates composition and prevents the duplication of validation logic.
+test_files:
+- spec/validation_delegation_spec.rb
+has_rdoc: