tram-validators 0.0.1

data/lib/tram/validators/reference_validator.rb

@@ -0,0 +1,14 @@
+# Checks that a model instance can be found by id
+#
+# @example Checks that AdminPolicy.new(user).valid?
+#   validates :user_key, reference: { model: User, find_by: :key }
+#
+class ReferenceValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    model = options.fetch(:model) { raise "You should define :model option" }
+    key   = options.fetch(:find_by, :id)
+
+    return if model.find_by(key => value)
+    record.errors.add attribute, :not_found
+  end
+end

data/lib/tram/validators/size_validator.rb

@@ -0,0 +1,37 @@
+# Compares size of array to given value or another attribute
+#
+# @example
+#   validates :names,  size: { less_than: 6 }
+#   validates :values, size: { equal_to: :names }
+#
+class SizeValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    size = value.size if value.is_a? Array
+    Tram::Validators::CONDITIONS.each do |key, block|
+      check(key, record, attribute, size, &block)
+    end
+  end
+
+  private
+
+  def check(condition, record, attribute, size)
+    return unless options.key? condition
+
+    limit = extract_limit(record, condition)
+    return if size && limit && yield(size, limit.to_i)
+
+    record.errors.add attribute, error_key(condition), size: size, limit: limit
+  end
+
+  def extract_limit(record, condition)
+    value = options[condition]
+    return value.to_s.to_i if value.to_s.to_i == value
+    value.to_s.split(".").inject(record) { |obj, meth| obj&.send(meth) }
+  end
+
+  def error_key(condition)
+    value = options[condition]
+    name = value.to_s.underscore.gsub(".", "_") unless value.to_s.to_i == value
+    ["size", condition, name].compact.join("_").to_sym
+  end
+end

data/lib/tram/validators/validity_validator.rb

@@ -0,0 +1,27 @@
+# Checks that value of some attribute is valid per se
+# Otherwise populates the record with the attribute's validation errors
+#
+# With option `original_keys: true` it copies value's errors to the record
+# under their original keys, as if the [#record] had attributes of the [#value].
+# Otherwise the errors are copied under the [#attribute] key.
+#
+# This is necessary for validation of the form models, as well as
+# other decorated objects.
+#
+# @example Checks that user.valid? returns true
+#   validates :user, validity: { nested_keys: true }
+#
+class ValidityValidator < ActiveModel::EachValidator
+  def validate_each(record, attribute, value)
+    if !value.respond_to? :invalid?
+      record.errors.add attribute, :invalidable, record:    record,
+                                                 attribute: attribute,
+                                                 value:     value
+    elsif value.invalid?
+      value.errors.messages.each do |key, messages|
+        error_key = Tram::Validators.error_key(key, attribute, options)
+        messages.each { |message| record.errors.add error_key, message }
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+require "pry"
+require "tram-validators"
+
+require_relative "support/invalid_with_error"
+
+RSpec.configure do |config|
+  config.order = :random
+  config.filter_run focus: true
+  config.run_all_when_everything_filtered = true
+
+  # Prepare the Test namespace for constants defined in specs
+  config.around(:each) do |example|
+    Test = Class.new(Module)
+    example.run
+    Object.send :remove_const, :Test
+  end
+end

data/spec/support/invalid_with_error.rb

@@ -0,0 +1,10 @@
+RSpec::Matchers.define :be_invalid_with_error do |key, name = nil|
+  match do |object|
+    expect(object).not_to be_valid
+
+    error = object.errors.messages[key.to_sym].to_a.first
+    satisfy_condition = name ? match(/\.#{name}\z/) : be_present
+
+    expect(error).to satisfy_condition
+  end
+end

data/spec/tram-validators/consistency_validator_spec.rb

@@ -0,0 +1,131 @@
+RSpec.describe ConsistencyValidator do
+  before do
+    Test::Subject = Struct.new(:foo, :bar) do
+      include ActiveModel::Validations
+    end
+
+    Test::Subject.validates :foo, consistency: options
+  end
+
+  subject { Test::Subject.new(foo, double(baz: 2)) }
+
+  context "equal_to attribute" do
+    let(:options) { { equal_to: "bar.baz" } }
+
+    context "when attribute equals to limit" do
+      let(:foo) { 2 }
+      it { is_expected.to be_valid }
+    end
+
+    context "when attribute is less than limit" do
+      let(:foo) { 1 }
+      it { is_expected.to be_invalid_with_error :foo, :equal_to_bar_baz }
+    end
+
+    context "when attribute is greater than limit" do
+      let(:foo) { 3 }
+      it { is_expected.to be_invalid_with_error :foo, :equal_to_bar_baz }
+    end
+  end
+
+  context "other_than attribute" do
+    let(:options) { { other_than: "bar.baz" } }
+
+    context "when attribute equals to limit" do
+      let(:foo) { 2 }
+      it { is_expected.to be_invalid_with_error :foo, :other_than_bar_baz }
+    end
+
+    context "when attribute is less than limit" do
+      let(:foo) { 1 }
+      it { is_expected.to be_valid }
+    end
+
+    context "when attribute is greater than limit" do
+      let(:foo) { 3 }
+      it { is_expected.to be_valid }
+    end
+  end
+
+  context "greater_than attribute" do
+    let(:options) { { greater_than: "bar.baz" } }
+
+    context "when attribute equals to limit" do
+      let(:foo) { 2 }
+      it { is_expected.to be_invalid_with_error :foo, :greater_than_bar_baz }
+    end
+
+    context "when attribute is less than limit" do
+      let(:foo) { 1 }
+      it { is_expected.to be_invalid_with_error :foo, :greater_than_bar_baz }
+    end
+
+    context "when attribute is greater than limit" do
+      let(:foo) { 3 }
+      it { is_expected.to be_valid }
+    end
+  end
+
+  context "greater_than_or_equal_to attribute" do
+    let(:options) { { greater_than_or_equal_to: "bar.baz" } }
+
+    context "when attribute equals to limit" do
+      let(:foo) { 2 }
+      it { is_expected.to be_valid }
+    end
+
+    context "when attribute is less than limit" do
+      let(:foo) { 1 }
+      it do
+        is_expected.to be_invalid_with_error \
+          :foo, :greater_than_or_equal_to_bar_baz
+      end
+    end
+
+    context "when attribute is greater than limit" do
+      let(:foo) { 3 }
+      it { is_expected.to be_valid }
+    end
+  end
+
+  context "less_than attribute" do
+    let(:options) { { less_than: "bar.baz" } }
+
+    context "when attribute equals to limit" do
+      let(:foo) { 2 }
+      it { is_expected.to be_invalid_with_error :foo, :less_than_bar_baz }
+    end
+
+    context "when attribute is less than limit" do
+      let(:foo) { 1 }
+      it { is_expected.to be_valid }
+    end
+
+    context "when attribute is greater than limit" do
+      let(:foo) { 3 }
+      it { is_expected.to be_invalid_with_error :foo, :less_than_bar_baz }
+    end
+  end
+
+  context "less_than_or_equal_to attribute" do
+    let(:options) { { less_than_or_equal_to: "bar.baz" } }
+
+    context "when attribute equals to limit" do
+      let(:foo) { 2 }
+      it { is_expected.to be_valid }
+    end
+
+    context "when attribute is less than limit" do
+      let(:foo) { 1 }
+      it { is_expected.to be_valid }
+    end
+
+    context "when attribute is greater than limit" do
+      let(:foo) { 3 }
+      it do
+        is_expected.to be_invalid_with_error \
+          :foo, :less_than_or_equal_to_bar_baz
+      end
+    end
+  end
+end

data/spec/tram-validators/contract_validator_spec.rb

@@ -0,0 +1,58 @@
+RSpec.describe ContractValidator do
+  before do
+    class Test::Contract < SimpleDelegator
+      include ActiveModel::Validations
+      validates :bar, presence: true
+    end
+
+    Test::Subject = Struct.new(:foo) do
+      include ActiveModel::Validations
+    end
+
+    Test::Subject.validates :foo, contract: { policy: Test::Contract, **opts }
+  end
+
+  subject { Test::Subject.new(double(bar: value)) }
+
+  context "without key option" do
+    let(:opts) { {} }
+
+    context "when value satisfies contract" do
+      let(:value) { 1 }
+      it { is_expected.to be_valid }
+    end
+
+    context "when value breaks contract" do
+      let(:value) { nil }
+      it { is_expected.to be_invalid_with_error :foo }
+    end
+  end
+
+  context "with original_keys option" do
+    let(:opts) { { original_keys: true } }
+
+    context "when value satisfies contract" do
+      let(:value) { 1 }
+      it { is_expected.to be_valid }
+    end
+
+    context "when value breaks contract" do
+      let(:value) { nil }
+      it { is_expected.to be_invalid_with_error :bar }
+    end
+  end
+
+  context "with nested_keys option" do
+    let(:opts) { { nested_keys: true } }
+
+    context "when value satisfies contract" do
+      let(:value) { 1 }
+      it { is_expected.to be_valid }
+    end
+
+    context "when value breaks contract" do
+      let(:value) { nil }
+      it { is_expected.to be_invalid_with_error "foo[bar]" }
+    end
+  end
+end

data/spec/tram-validators/each_validator_spec.rb

@@ -0,0 +1,35 @@
+RSpec.describe EachValidator do
+  before do
+    Test::Subject = Struct.new(:list) do
+      include ActiveModel::Validations
+      validates :list, each: { presence: true }
+    end
+  end
+
+  subject { Test::Subject.new(list) }
+
+  context "when all elements of array satisfy validation rule" do
+    let(:list) { %i(foo bar baz) }
+    it { is_expected.to be_valid }
+  end
+
+  context "when some element of array breaks validation rule" do
+    let(:list) { [:foo, :bar, nil] }
+    it { is_expected.to be_invalid_with_error "list[2]" }
+  end
+
+  context "when value is an empty array" do
+    let(:list) { [] }
+    it { is_expected.to be_valid }
+  end
+
+  context "when value is nil" do
+    let(:list) { :foo }
+    it { is_expected.to be_valid }
+  end
+
+  context "when value is neiter nil nor an array" do
+    let(:list) { :foo }
+    it { is_expected.to be_valid }
+  end
+end

data/spec/tram-validators/outcome_validator_spec.rb

@@ -0,0 +1,27 @@
+RSpec.describe OutcomeValidator do
+  before do
+    Test::Subject = Struct.new(:foo, :bar) do
+      include ActiveModel::Validations
+      validates :foo, outcome: { value: "bar.baz", presence: true }
+    end
+  end
+
+  subject { Test::Subject.new(1, bar) }
+
+  context "when outcome is valid" do
+    let(:bar) { double baz: 1 }
+    it { is_expected.to be_valid }
+  end
+
+  context "when outcome is invalid" do
+    let(:bar) { double baz: nil }
+    it { is_expected.to be_invalid_with_error :foo, :"bar_baz_presence" }
+  end
+
+  context "when outcome produces nil inside chain" do
+    let(:bar) { nil }
+    it "uses nil outcome" do
+      expect(subject).to be_invalid_with_error :foo, :"bar_baz_presence"
+    end
+  end
+end

data/spec/tram-validators/size_validator_spec.rb

@@ -0,0 +1,347 @@
+RSpec.describe SizeValidator do
+  before do
+    Test::Subject = Struct.new(:foo, :bar, :baz) do
+      include ActiveModel::Validations
+    end
+  end
+
+  let(:foo) { %w(Color Size) }
+  let(:bar) { double baz: 2 }
+  let(:baz) { double qux: %w(Green XXXL) }
+
+  subject { Test::Subject.new(foo, bar, baz) }
+
+  context "equal_to number" do
+    before { Test::Subject.validates :foo, size: { equal_to: 2 } }
+
+    context "when attribute has size equal to limit" do
+      let(:foo) { %w(Color Size) }
+      it { is_expected.to be_valid }
+    end
+
+    context "when attribute has size less than limit" do
+      let(:foo) { %w(Color) }
+      it { is_expected.to be_invalid_with_error :foo, :size_equal_to }
+    end
+
+    context "when attribute has size greater than limit" do
+      let(:foo) { %w(Color Size Style) }
+      it { is_expected.to be_invalid_with_error :foo, :size_equal_to }
+    end
+
+    context "when attribute is not an array" do
+      let(:foo) { 1 }
+      it { is_expected.to be_invalid_with_error :foo, :size_equal_to }
+    end
+  end
+
+  context "other_than number" do
+    before { Test::Subject.validates :foo, size: { other_than: 2 } }
+
+    context "when attribute has size equal to limit" do
+      let(:foo) { %w(Color Size) }
+      it { is_expected.to be_invalid_with_error :foo, :size_other_than }
+    end
+
+    context "when attribute has size less than limit" do
+      let(:foo) { %w(Color) }
+      it { is_expected.to be_valid }
+    end
+
+    context "when attribute has size greater than limit" do
+      let(:foo) { %w(Color Size Style) }
+      it { is_expected.to be_valid }
+    end
+
+    context "when attribute is not an array" do
+      let(:foo) { 1 }
+      it { is_expected.to be_invalid_with_error :foo, :size_other_than }
+    end
+  end
+
+  context "greater_than number" do
+    before { Test::Subject.validates :foo, size: { greater_than: 2 } }
+
+    context "when attribute has size equal to limit" do
+      let(:foo) { %w(Color Size) }
+      it { is_expected.to be_invalid_with_error :foo, :size_greater_than }
+    end
+
+    context "when attribute has size less than limit" do
+      let(:foo) { %w(Color) }
+      it { is_expected.to be_invalid_with_error :foo, :size_greater_than }
+    end
+
+    context "when attribute has size greater than limit" do
+      let(:foo) { %w(Color Size Style) }
+      it { is_expected.to be_valid }
+    end
+
+    context "when attribute is not an array" do
+      let(:foo) { 1 }
+      it { is_expected.to be_invalid_with_error :foo, :size_greater_than }
+    end
+  end
+
+  context "greater_than_or_equal_to number" do
+    before do
+      Test::Subject.validates :foo, size: { greater_than_or_equal_to: 2 }
+    end
+
+    context "when attribute has size equal to limit" do
+      let(:foo) { %w(Color Size) }
+      it { is_expected.to be_valid }
+    end
+
+    context "when attribute has size less than limit" do
+      let(:foo) { %w(Color) }
+      it do
+        is_expected
+          .to be_invalid_with_error :foo, :size_greater_than_or_equal_to
+      end
+    end
+
+    context "when attribute has size greater than limit" do
+      let(:foo) { %w(Color Size Style) }
+      it { is_expected.to be_valid }
+    end
+
+    context "when attribute is not an array" do
+      let(:foo) { 1 }
+      it do
+        is_expected
+          .to be_invalid_with_error :foo, :size_greater_than_or_equal_to
+      end
+    end
+  end
+
+  context "less_than number" do
+    before { Test::Subject.validates :foo, size: { less_than: 2 } }
+
+    context "when attribute has size equal to limit" do
+      let(:foo) { %w(Color Size) }
+      it { is_expected.to be_invalid_with_error :foo, :size_less_than }
+    end
+
+    context "when attribute has size less than limit" do
+      let(:foo) { %w(Color) }
+      it { is_expected.to be_valid }
+    end
+
+    context "when attribute has size greater than limit" do
+      let(:foo) { %w(Color Size Style) }
+      it { is_expected.to be_invalid_with_error :foo, :size_less_than }
+    end
+
+    context "when attribute is not an array" do
+      let(:foo) { 1 }
+      it { is_expected.to be_invalid_with_error :foo, :size_less_than }
+    end
+  end
+
+  context "less_than_or_equal_to number" do
+    before { Test::Subject.validates :foo, size: { less_than_or_equal_to: 2 } }
+
+    context "when attribute has size equal to limit" do
+      let(:foo) { %w(Color Size) }
+      it { is_expected.to be_valid }
+    end
+
+    context "when attribute has size less than limit" do
+      let(:foo) { %w(Color) }
+      it { is_expected.to be_valid }
+    end
+
+    context "when attribute has size greater than limit" do
+      let(:foo) { %w(Color Size Style) }
+      it do
+        is_expected.to be_invalid_with_error :foo, :size_less_than_or_equal_to
+      end
+    end
+
+    context "when attribute is not an array" do
+      let(:foo) { 1 }
+      it do
+        is_expected.to be_invalid_with_error :foo, :size_less_than_or_equal_to
+      end
+    end
+  end
+
+  context "equal_to attribute" do
+    before { Test::Subject.validates :foo, size: { equal_to: "bar.baz" } }
+
+    context "when attribute has size equal to limit" do
+      let(:foo) { %w(Color Size) }
+      it { is_expected.to be_valid }
+    end
+
+    context "when attribute has size less than limit" do
+      let(:foo) { %w(Color) }
+      it do
+        is_expected.to be_invalid_with_error :foo, :size_equal_to_bar_baz
+      end
+    end
+
+    context "when attribute has size greater than limit" do
+      let(:foo) { %w(Color Size Style) }
+      it do
+        is_expected.to be_invalid_with_error :foo, :size_equal_to_bar_baz
+      end
+    end
+
+    context "when attribute is not an array" do
+      let(:foo) { 1 }
+      it do
+        is_expected.to be_invalid_with_error :foo, :size_equal_to_bar_baz
+      end
+    end
+  end
+
+  context "other_than attribute" do
+    before { Test::Subject.validates :foo, size: { other_than: "bar.baz" } }
+
+    context "when attribute has size equal to limit" do
+      let(:foo) { %w(Color Size) }
+      it do
+        is_expected.to be_invalid_with_error :foo, :size_other_than_bar_baz
+      end
+    end
+
+    context "when attribute has size less than limit" do
+      let(:foo) { %w(Color) }
+      it { is_expected.to be_valid }
+    end
+
+    context "when attribute has size greater than limit" do
+      let(:foo) { %w(Color Size Style) }
+      it { is_expected.to be_valid }
+    end
+
+    context "when attribute is not an array" do
+      let(:foo) { 1 }
+      it do
+        is_expected.to be_invalid_with_error :foo, :size_other_than_bar_baz
+      end
+    end
+  end
+
+  context "greater_than attribute" do
+    before { Test::Subject.validates :foo, size: { greater_than: "bar.baz" } }
+
+    context "when attribute has size equal to limit" do
+      let(:foo) { %w(Color Size) }
+      it do
+        is_expected.to be_invalid_with_error :foo, :size_greater_than_bar_baz
+      end
+    end
+
+    context "when attribute has size less than limit" do
+      let(:foo) { %w(Color) }
+      it do
+        is_expected.to be_invalid_with_error :foo, :size_greater_than_bar_baz
+      end
+    end
+
+    context "when attribute has size greater than limit" do
+      let(:foo) { %w(Color Size Style) }
+      it { is_expected.to be_valid }
+    end
+
+    context "when attribute is not an array" do
+      let(:foo) { 1 }
+      it do
+        is_expected.to be_invalid_with_error :foo, :size_greater_than_bar_baz
+      end
+    end
+  end
+
+  context "greater_than_or_equal_to attribute" do
+    before do
+      Test::Subject.validates :foo,
+                              size: { greater_than_or_equal_to: "bar.baz" }
+    end
+
+    context "when attribute has size equal to limit" do
+      let(:foo) { %w(Color Size) }
+      it { is_expected.to be_valid }
+    end
+
+    context "when attribute has size less than limit" do
+      let(:foo) { %w(Color) }
+      it do
+        is_expected
+          .to be_invalid_with_error :foo, :size_greater_than_or_equal_to_bar_baz
+      end
+    end
+
+    context "when attribute has size greater than limit" do
+      let(:foo) { %w(Color Size Style) }
+
+      it { is_expected.to be_valid }
+    end
+
+    context "when attribute is not an array" do
+      let(:foo) { 1 }
+      it do
+        is_expected
+          .to be_invalid_with_error :foo, :size_greater_than_or_equal_to_bar_baz
+      end
+    end
+  end
+
+  context "less_than attribute" do
+    before { Test::Subject.validates :foo, size: { less_than: "bar.baz" } }
+
+    context "when attribute has size equal to limit" do
+      let(:foo) { %w(Color Size) }
+      it { is_expected.to be_invalid_with_error :foo, :size_less_than_bar_baz }
+    end
+
+    context "when attribute has size less than limit" do
+      let(:foo) { %w(Color) }
+      it { is_expected.to be_valid }
+    end
+
+    context "when attribute has size greater than limit" do
+      let(:foo) { %w(Color Size Style) }
+      it { is_expected.to be_invalid_with_error :foo, :size_less_than_bar_baz }
+    end
+
+    context "when attribute is not an array" do
+      let(:foo) { 1 }
+      it { is_expected.to be_invalid_with_error :foo, :size_less_than_bar_baz }
+    end
+  end
+
+  context "less_than_or_equal_to attribute" do
+    before do
+      Test::Subject.validates :foo, size: { less_than_or_equal_to: "bar.baz" }
+    end
+
+    context "when attribute has size equal to limit" do
+      let(:foo) { %w(Color Size) }
+      it { is_expected.to be_valid }
+    end
+
+    context "when attribute has size less than limit" do
+      let(:foo) { %w(Color) }
+      it { is_expected.to be_valid }
+    end
+
+    context "when attribute has size greater than limit" do
+      let(:foo) { %w(Color Size Style) }
+      it do
+        is_expected.to be_invalid_with_error \
+          :foo, :size_less_than_or_equal_to_bar_baz
+      end
+    end
+
+    context "when attribute is not an array" do
+      let(:foo) { 1 }
+      it do
+        is_expected.to be_invalid_with_error \
+          :foo, :size_less_than_or_equal_to_bar_baz
+      end
+    end
+  end
+end