tram-validators 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: aca5b01edeaa35458d5ba907676b8bed73a60f1e
+  data.tar.gz: 9c65185129ee67af6848516c0623405676176383
+SHA512:
+  metadata.gz: dcf7914965ea2df8011562c7dc85b4f0f5fd22fe388421558394fdbcb6e39ec6cc5fbb885f79dc0a024a7bc4016159770791c855db8ba51a44a8135af0bcaaf0
+  data.tar.gz: 61dd66c80636c75067a5c2eb438d682a3fae75a818113f905e5d806296a741e1243f516a544059ddae681d2206a2ca16e1460dbb34f472d4a4f64f33d0def8b6

data/.codeclimate.yml

@@ -0,0 +1,18 @@
+---
+engines:
+  bundler-audit:
+    enabled: true
+  duplication:
+    enabled: true
+    config:
+      languages:
+      - ruby
+  fixme:
+    enabled: true
+  rubocop:
+    enabled: true
+ratings:
+  paths:
+  - "**.rb"
+exclude_paths:
+- spec/

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.rspec

@@ -0,0 +1,3 @@
+--require spec_helper
+--format documentation
+--color

data/.rubocop.yml

@@ -0,0 +1,27 @@
+---
+AllCops:
+  DisplayCopNames:    true
+  DisplayStyleGuide:  true
+  StyleGuideCopsOnly: true
+  TargetRubyVersion:  2.3
+
+Style/Alias:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  EnforcedStyle: compact
+
+Style/FileName:
+  Enabled: false
+
+Style/FrozenStringLiteralComment:
+  Enabled: false
+
+Style/ModuleFunction:
+  Enabled: false
+
+Style/StringLiterals:
+  EnforcedStyle: double_quotes
+
+Style/StringLiteralsInInterpolation:
+  EnforcedStyle: double_quotes

data/.travis.yml

@@ -0,0 +1,14 @@
+---
+sudo:     false
+language: ruby
+cache:    bundler
+script:
+  - bundle exec rspec
+  - bundle exec rubocop
+rvm:
+  - 2.3.0
+  - ruby-head
+before_install: gem install bundler
+matrix:
+  allow_failures:
+    - rvm: ruby-head

data/Gemfile

@@ -0,0 +1,9 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in tram-form.gemspec
+gemspec
+
+group :test, :development do
+  gem "pry"
+  gem "pry-byebug"
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Andrew Kozin (nepalez), Evil Martians
+
+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,134 @@
+# Tram::Validators
+
+Collection of ActiveModel validators for rails projects with focus on composition of standalone policy objects.
+
+<a href="https://evilmartians.com/">
+<img src="https://evilmartians.com/badges/sponsored-by-evil-martians.svg" alt="Sponsored by Evil Martians" width="236" height="54"></a>
+
+[![Gem Version][gem-badger]][gem]
+[![Build Status][travis-badger]][travis]
+[![Dependency Status][gemnasium-badger]][gemnasium]
+[![Code Climate][codeclimate-badger]][codeclimate]
+
+## Installation
+
+```ruby
+gem "tram-validators"
+```
+
+## Usage
+
+Below is a short review of available validators. Read the [specs][specs] for more details:
+
+### Contract Validator
+
+Checks that a value satisfies a contract, represented by a standalone validator (policy object).
+It applies policy validator, and collects its messages under corresponding keys.
+
+```ruby
+class PolicyObject < SimpleDelegator
+  include ActiveModel::Validations
+  validates :bar, presence: true
+end
+
+# PolicyObject.new(record.foo).valid? == true
+# collects original error messages from policy under the key `foo`
+validates :foo, contract: { policy: PolicyObject }
+
+# collects the same messages from policy under their original keys (`bar`)
+validates :foo, contract: { policy: PolicyObject, original_keys: true }
+
+# collects the same messages from policy under nested keys (`foo[bar]`)
+validates :foo, contract: { policy: PolicyObject, nested_keys: true }
+```
+
+### Validity Validator
+
+Checks that an attribute is valid per se.
+It collects original error messages under corresponding keys.
+
+```ruby
+# record.foo.valid? == true
+# collects original error messages under the key `foo`
+validates :foo, validity: true
+
+# collects the same messages from policy under their original keys (`bar`)
+validates :foo, validity: { original_keys: true }
+
+# collects the same messages from policy under nested keys (`foo[bar]`)
+validates :foo, validity: { nested_keys: true }
+```
+
+### Each Validator
+
+Applies validation rule to every element of the collection (that responds to `to_a`).
+
+```ruby
+# Checks that every element of record.list is present
+# collects original errors under the key `list[i]` (i for index of invalid item)
+validates :list, each: { presence: true }
+```
+
+### Outcome Validator
+
+Validates value by checking another method depending on it.
+
+```ruby
+# Validates `user_id` by checking that `user.role` (depending on user_id) is set
+# adds error `user_role_presence` to the original attribute  `user_id`
+validates :user_id, outcome: { value: "user.role", presence: true }
+```
+
+This technics is useful in form objects where you should attach errors to the original fields accessible to the user.
+
+### Consistency Validator
+
+Compares a value of some attribute to a value of another attribute or method chain.
+Supports all keys from the standard rails [numericality validator][numericality].
+
+```ruby
+# record.foo < record.bar.baz
+# adds error named `less_than_bar_baz` under the key `foo`
+validates :foo, consistency: { less_than: "bar.baz" }
+```
+
+### Size Validator
+
+Compares size of array to given value or another attribute.
+Supports all keys from the standard rails [numericality validator][numericality].
+
+```ruby
+# record.names.size < 6
+# adds error named `size_less_than` under the key `names`
+validates :names, size: { less_than: 6 }
+
+# record.values.size == record.parent&.names&.size
+# adds error named `size_equal_to_parent_names_size` under the key `names`
+validates :values, size: { equal_to: "parent.names.size" }
+```
+
+### Reference Validator
+
+This is an AR-dependent validator, that checks an instance can be extracted from database by given key.
+
+```ruby
+# Checks that User.find_by(record.user_key).present?
+validates :user_key, reference: { model: User, find_by: :key }
+```
+
+Like the outcome validator above, it can be useful for validation of form objects.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+
+[specs]: ./spec/tram-validators
+[numericality]: http://guides.rubyonrails.org/active_record_validations.html#numericality
+[codeclimate-badger]: https://img.shields.io/codeclimate/github/tram-rb/tram-validators.svg?style=flat
+[codeclimate]: https://codeclimate.com/github/tram-rb/tram-validators
+[gem-badger]: https://img.shields.io/gem/v/tram-validators.svg?style=flat
+[gem]: https://rubygems.org/gems/tram-validators
+[gemnasium-badger]: https://img.shields.io/gemnasium/tram-rb/tram-validators.svg?style=flat
+[gemnasium]: https://gemnasium.com/tram-rb/tram-validators
+[travis-badger]: https://img.shields.io/travis/tram-rb/tram-validators/master.svg?style=flat
+[travis]: https://travis-ci.org/tram-rb/tram-validators

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/tram-validators.rb

@@ -0,0 +1 @@
+require_relative "tram/validators"

data/lib/tram/validators.rb

@@ -0,0 +1,64 @@
+require "active_model"
+require "active_support/inflector"
+
+module Tram
+  module Validators
+    # Standard conditions to check
+    CONDITIONS = {
+      equal_to:                 ->(value, limit) { value == limit },
+      other_than:               ->(value, limit) { value != limit },
+      less_than:                ->(value, limit) { value <  limit },
+      less_than_or_equal_to:    ->(value, limit) { value <= limit },
+      greater_than:             ->(value, limit) { value >  limit },
+      greater_than_or_equal_to: ->(value, limit) { value >= limit }
+    }.freeze
+
+    class << self
+      # Gets value of chained attribute
+      def chained_value(record, chain)
+        chain.to_s.split(".").inject(record) { |obj, name| obj&.send(name) }
+      end
+
+      # Provides standard key for error collected by standalone validators
+      def error_key(source, target, nested_keys: nil, original_keys: nil, **)
+        return source if     original_keys
+        return target unless nested_keys
+        source.to_s
+              .split(/\[|\]/)
+              .compact
+              .inject(target) { |obj, key| "#{obj}[#{key}]" }
+              .to_sym
+      end
+
+      # Extracts nested validators from options
+      def validators(attr, options, *blacklist)
+        options.map.with_object({}) do |(key, opts), obj|
+          name = key.to_s
+
+          next if blacklist.map(&:to_s).include? name
+          next if %w(allow_nil if unless on message).include? name
+
+          opts = {} unless opts.is_a? Hash
+          obj[key] = find_validator_by_name(name).new(attributes: attr, **opts)
+        end
+      end
+
+      private
+
+      def find_validator_by_name(name)
+        klass_name = "#{name.camelize}Validator"
+        klass_name.constantize
+      rescue
+        ActiveModel::Validations.const_get(klass_name)
+      end
+    end
+
+    require_relative "validators/consistency_validator"
+    require_relative "validators/contract_validator"
+    require_relative "validators/each_validator"
+    require_relative "validators/outcome_validator"
+    require_relative "validators/reference_validator"
+    require_relative "validators/size_validator"
+    require_relative "validators/validity_validator"
+  end
+end

data/lib/tram/validators/consistency_validator.rb

@@ -0,0 +1,26 @@
+# Compares value of the attribute to value of another attribute
+#
+# @example Compares price to source.price
+#   validates :price, consistency: { greater_than: 'source.price' }
+#   # I18n error key 'price.greater_than_source.price'
+#
+class ConsistencyValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    Tram::Validators::CONDITIONS.each do |key, block|
+      check(key, record, attribute, value, &block)
+    end
+  end
+
+  private
+
+  def check(condition, record, attribute, value)
+    chain = options[condition]
+    return if chain.blank?
+
+    other_value = Tram::Validators.chained_value(record, chain)
+    return if value && other_value && yield(value, other_value)
+
+    error_name = [condition, chain.to_s.split(".")].flatten.join("_").to_sym
+    record.errors.add attribute, error_name, value: value, other: other_value
+  end
+end

data/lib/tram/validators/contract_validator.rb

@@ -0,0 +1,14 @@
+# Validates attribute by calling given type with the attribute's value
+#
+# @example Checks that AdminPolicy.new(user).valid?
+#   validates :user, contract: { policy: AdminPolicy, nested_keys: true }
+#
+class ContractValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    return unless options[:policy]
+    options[:policy].new(value).tap(&:valid?).errors.messages.each do |key, msg|
+      error_key = Tram::Validators.error_key(key, attribute, options)
+      msg.each { |message| record.errors.add error_key, message }
+    end
+  end
+end

data/lib/tram/validators/each_validator.rb

@@ -0,0 +1,30 @@
+# Applies validator to every element of the collection
+class EachValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, values)
+    return unless values.is_a? Enumerable
+    values.each_with_index do |value, index|
+      item = record.dup.tap { |rec| rec.errors.clear }
+
+      call_validations(item, attribute, value)
+
+      copy_errors(item, record, attribute, index)
+    end
+  end
+
+  private
+
+  def call_validations(item, attribute, value)
+    Tram::Validators.validators(@attributes, options).each do |_, validator|
+      validator.validate_each item, attribute, value
+    end
+  end
+
+  def copy_errors(item, record, attribute, index)
+    item.errors.messages.each do |original_key, messages|
+      messages.each do |message|
+        key = original_key.to_s.sub /\A#{attribute}/, "#{attribute}[#{index}]"
+        record.errors.add key.to_sym, message
+      end
+    end
+  end
+end

data/lib/tram/validators/outcome_validator.rb

@@ -0,0 +1,50 @@
+# Validates attribute by applying validation rule not to the attribute itself,
+# but to another parameter, whose value depends on the attribute.
+#
+# The resulting error is collected under the attribute's key, which
+# is necessary to correctly bind the error to the field, that causes
+# the problem.
+#
+# @example
+#   let(:user) { User.find_by(id: user_id) }
+#   validates :user_id, outcome: { value: 'user.name', presence: true }
+#   # user_id.user_name_presence
+#
+class OutcomeValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    dependency = options[:value].to_s.gsub(".", "_")
+    dependent  = Tram::Validators.chained_value(record, options[:value])
+    validators = Tram::Validators.validators(@attributes, options, :value)
+
+    sandbox = record.dup
+    validators.each do |condition, validator|
+      next if valid_in_sandbox(sandbox, attribute, dependent, validator)
+
+      key  = message_key(dependency, condition)
+      text = message(record, attribute, value, dependent, key)
+      record.errors.add attribute, text
+    end
+  end
+
+  private
+
+  def valid_in_sandbox(sandbox, attribute, dependent, validator)
+    sandbox.errors.clear
+    validator.validate_each(sandbox, attribute, dependent)
+    sandbox.errors.empty?
+  end
+
+  def message_key(dependency, condition)
+    [dependency, condition.to_s].compact.join("_").to_sym
+  end
+
+  def message(record, attribute, value, dependent, message_key)
+    model = record.class.name.underscore
+    scope = %W(active_model errors models #{model} attributes #{attribute})
+    I18n.t message_key, record:      record,
+                        attribute:   attribute,
+                        value:       value,
+                        delependent: dependent,
+                        scope:       scope
+  end
+end