2014-01-23 18:07:36 +00:00
|
|
|
module Shoulda
|
2010-12-15 22:34:19 +00:00
|
|
|
module Matchers
|
2014-01-23 18:07:36 +00:00
|
|
|
module ActiveModel
|
|
|
|
# @private
|
|
|
|
class ValidationMatcher
|
Add ignoring_interference_by_writer to all matchers
`allow_value` matcher is, of course, concerned with setting values on a
particular attribute on a particular record, and then checking that the
record is valid after doing so. That comes with a caveat: if the
attribute is overridden in such a way so that the same value going into
the attribute isn't the same value coming out of it, then `allow_value`
will balk -- it'll say, "I can't do that because that changes how I
work."
That's all well and good, but what the attribute intentionally changes
incoming values? ActiveRecord's typecasting behavior, for instance,
would trigger such an exception. What if the developer needs a way to
get around this? This is where `ignoring_interference_by_writer` comes
into play. You can tack it on to the end of the matcher, and you're free
to go on your way.
So, prior to this commit you could already apply it to `allow_value`,
but now in this commit it also works on any other matcher.
But, one little thing: sometimes using this qualifier isn't going to
work. Perhaps you or something else actually *is* overriding the
attribute to change incoming values in a specific way, and perhaps the
value that comes out makes the record fail validation, and there's
nothing you can do about it. So in this case, even if you're using
`ignoring_interference_by_writer`, we want to inform you about what the
attribute is doing -- what the input and output was. And so we do.
2015-12-31 01:47:46 +00:00
|
|
|
include Qualifiers::IgnoringInterferenceByWriter
|
|
|
|
|
2010-12-15 22:34:19 +00:00
|
|
|
def initialize(attribute)
|
Add ignoring_interference_by_writer to all matchers
`allow_value` matcher is, of course, concerned with setting values on a
particular attribute on a particular record, and then checking that the
record is valid after doing so. That comes with a caveat: if the
attribute is overridden in such a way so that the same value going into
the attribute isn't the same value coming out of it, then `allow_value`
will balk -- it'll say, "I can't do that because that changes how I
work."
That's all well and good, but what the attribute intentionally changes
incoming values? ActiveRecord's typecasting behavior, for instance,
would trigger such an exception. What if the developer needs a way to
get around this? This is where `ignoring_interference_by_writer` comes
into play. You can tack it on to the end of the matcher, and you're free
to go on your way.
So, prior to this commit you could already apply it to `allow_value`,
but now in this commit it also works on any other matcher.
But, one little thing: sometimes using this qualifier isn't going to
work. Perhaps you or something else actually *is* overriding the
attribute to change incoming values in a specific way, and perhaps the
value that comes out makes the record fail validation, and there's
nothing you can do about it. So in this case, even if you're using
`ignoring_interference_by_writer`, we want to inform you about what the
attribute is doing -- what the input and output was. And so we do.
2015-12-31 01:47:46 +00:00
|
|
|
super
|
2010-12-15 22:34:19 +00:00
|
|
|
@attribute = attribute
|
2015-12-14 00:01:14 +00:00
|
|
|
@expects_strict = false
|
|
|
|
@subject = nil
|
|
|
|
@last_submatcher_run = nil
|
|
|
|
@expected_message = nil
|
|
|
|
@expects_custom_validation_message = false
|
2012-09-12 00:53:21 +00:00
|
|
|
end
|
|
|
|
|
Add ignoring_interference_by_writer to all matchers
`allow_value` matcher is, of course, concerned with setting values on a
particular attribute on a particular record, and then checking that the
record is valid after doing so. That comes with a caveat: if the
attribute is overridden in such a way so that the same value going into
the attribute isn't the same value coming out of it, then `allow_value`
will balk -- it'll say, "I can't do that because that changes how I
work."
That's all well and good, but what the attribute intentionally changes
incoming values? ActiveRecord's typecasting behavior, for instance,
would trigger such an exception. What if the developer needs a way to
get around this? This is where `ignoring_interference_by_writer` comes
into play. You can tack it on to the end of the matcher, and you're free
to go on your way.
So, prior to this commit you could already apply it to `allow_value`,
but now in this commit it also works on any other matcher.
But, one little thing: sometimes using this qualifier isn't going to
work. Perhaps you or something else actually *is* overriding the
attribute to change incoming values in a specific way, and perhaps the
value that comes out makes the record fail validation, and there's
nothing you can do about it. So in this case, even if you're using
`ignoring_interference_by_writer`, we want to inform you about what the
attribute is doing -- what the input and output was. And so we do.
2015-12-31 01:47:46 +00:00
|
|
|
def description
|
|
|
|
ValidationMatcher::BuildDescription.call(self, simple_description)
|
|
|
|
end
|
|
|
|
|
2013-03-04 03:34:38 +00:00
|
|
|
def on(context)
|
|
|
|
@context = context
|
|
|
|
self
|
|
|
|
end
|
|
|
|
|
2012-09-12 00:53:21 +00:00
|
|
|
def strict
|
2015-12-14 00:01:14 +00:00
|
|
|
@expects_strict = true
|
2012-09-12 00:53:21 +00:00
|
|
|
self
|
2010-12-15 22:34:19 +00:00
|
|
|
end
|
|
|
|
|
2015-12-14 00:01:14 +00:00
|
|
|
def expects_strict?
|
|
|
|
@expects_strict
|
2010-12-15 22:34:19 +00:00
|
|
|
end
|
|
|
|
|
2015-12-14 00:01:14 +00:00
|
|
|
def with_message(expected_message)
|
|
|
|
if expected_message
|
|
|
|
@expects_custom_validation_message = true
|
|
|
|
@expected_message = expected_message
|
2010-12-15 22:34:19 +00:00
|
|
|
end
|
2015-12-14 00:01:14 +00:00
|
|
|
|
|
|
|
self
|
2010-12-15 22:34:19 +00:00
|
|
|
end
|
|
|
|
|
2015-12-14 00:01:14 +00:00
|
|
|
def expects_custom_validation_message?
|
|
|
|
@expects_custom_validation_message
|
2010-12-15 22:34:19 +00:00
|
|
|
end
|
2012-09-12 00:53:21 +00:00
|
|
|
|
Add ignoring_interference_by_writer to all matchers
`allow_value` matcher is, of course, concerned with setting values on a
particular attribute on a particular record, and then checking that the
record is valid after doing so. That comes with a caveat: if the
attribute is overridden in such a way so that the same value going into
the attribute isn't the same value coming out of it, then `allow_value`
will balk -- it'll say, "I can't do that because that changes how I
work."
That's all well and good, but what the attribute intentionally changes
incoming values? ActiveRecord's typecasting behavior, for instance,
would trigger such an exception. What if the developer needs a way to
get around this? This is where `ignoring_interference_by_writer` comes
into play. You can tack it on to the end of the matcher, and you're free
to go on your way.
So, prior to this commit you could already apply it to `allow_value`,
but now in this commit it also works on any other matcher.
But, one little thing: sometimes using this qualifier isn't going to
work. Perhaps you or something else actually *is* overriding the
attribute to change incoming values in a specific way, and perhaps the
value that comes out makes the record fail validation, and there's
nothing you can do about it. So in this case, even if you're using
`ignoring_interference_by_writer`, we want to inform you about what the
attribute is doing -- what the input and output was. And so we do.
2015-12-31 01:47:46 +00:00
|
|
|
def matches?(subject)
|
|
|
|
@subject = subject
|
|
|
|
false
|
2015-12-14 00:01:14 +00:00
|
|
|
end
|
2012-09-12 13:47:20 +00:00
|
|
|
|
2015-12-14 00:01:14 +00:00
|
|
|
def failure_message
|
|
|
|
overall_failure_message.dup.tap do |message|
|
|
|
|
if failure_reason.present?
|
|
|
|
message << "\n"
|
|
|
|
message << Shoulda::Matchers.word_wrap(
|
|
|
|
failure_reason,
|
|
|
|
indent: 2
|
|
|
|
)
|
|
|
|
end
|
2014-06-27 22:39:39 +00:00
|
|
|
end
|
2015-12-14 00:01:14 +00:00
|
|
|
end
|
2014-06-27 22:39:39 +00:00
|
|
|
|
2015-12-14 00:01:14 +00:00
|
|
|
def failure_message_when_negated
|
|
|
|
overall_failure_message_when_negated.dup.tap do |message|
|
|
|
|
if failure_reason_when_negated.present?
|
|
|
|
message << "\n"
|
|
|
|
message << Shoulda::Matchers.word_wrap(
|
|
|
|
failure_reason_when_negated,
|
|
|
|
indent: 2
|
|
|
|
)
|
|
|
|
end
|
2012-09-12 13:47:20 +00:00
|
|
|
end
|
2015-12-14 00:01:14 +00:00
|
|
|
end
|
2014-06-27 22:39:39 +00:00
|
|
|
|
2015-12-14 00:01:14 +00:00
|
|
|
protected
|
|
|
|
|
|
|
|
attr_reader :attribute, :context, :subject, :last_submatcher_run
|
|
|
|
|
|
|
|
def model
|
|
|
|
subject.class
|
2012-09-12 13:47:20 +00:00
|
|
|
end
|
|
|
|
|
2015-12-14 00:01:14 +00:00
|
|
|
def allows_value_of(value, message = nil, &block)
|
|
|
|
matcher = allow_value_matcher(value, message, &block)
|
|
|
|
run_allow_or_disallow_matcher(matcher)
|
|
|
|
end
|
2013-03-27 18:13:46 +00:00
|
|
|
|
2015-12-14 00:01:14 +00:00
|
|
|
def disallows_value_of(value, message = nil, &block)
|
|
|
|
matcher = disallow_value_matcher(value, message, &block)
|
|
|
|
run_allow_or_disallow_matcher(matcher)
|
|
|
|
end
|
2014-06-27 22:39:39 +00:00
|
|
|
|
2015-12-14 00:01:14 +00:00
|
|
|
def allow_value_matcher(value, message = nil, &block)
|
|
|
|
build_allow_or_disallow_value_matcher(
|
|
|
|
matcher_class: AllowValueMatcher,
|
|
|
|
value: value,
|
|
|
|
message: message,
|
|
|
|
&block
|
|
|
|
)
|
|
|
|
end
|
|
|
|
|
|
|
|
def disallow_value_matcher(value, message = nil, &block)
|
|
|
|
build_allow_or_disallow_value_matcher(
|
|
|
|
matcher_class: DisallowValueMatcher,
|
|
|
|
value: value,
|
|
|
|
message: message,
|
|
|
|
&block
|
|
|
|
)
|
|
|
|
end
|
|
|
|
|
|
|
|
private
|
|
|
|
|
|
|
|
def overall_failure_message
|
|
|
|
Shoulda::Matchers.word_wrap(
|
|
|
|
"#{model.name} did not properly #{description}."
|
|
|
|
)
|
|
|
|
end
|
|
|
|
|
|
|
|
def overall_failure_message_when_negated
|
|
|
|
Shoulda::Matchers.word_wrap(
|
|
|
|
"Expected #{model.name} not to #{description}, but it did."
|
|
|
|
)
|
|
|
|
end
|
|
|
|
|
|
|
|
def failure_reason
|
|
|
|
last_submatcher_run.try(:failure_message)
|
|
|
|
end
|
|
|
|
|
|
|
|
def failure_reason_when_negated
|
|
|
|
last_submatcher_run.try(:failure_message_when_negated)
|
|
|
|
end
|
|
|
|
|
|
|
|
def build_allow_or_disallow_value_matcher(args)
|
|
|
|
matcher_class = args.fetch(:matcher_class)
|
|
|
|
value = args.fetch(:value)
|
|
|
|
message = args[:message]
|
|
|
|
|
|
|
|
matcher = matcher_class.new(value).
|
|
|
|
for(attribute).
|
|
|
|
with_message(message).
|
|
|
|
on(context).
|
Add ignoring_interference_by_writer to all matchers
`allow_value` matcher is, of course, concerned with setting values on a
particular attribute on a particular record, and then checking that the
record is valid after doing so. That comes with a caveat: if the
attribute is overridden in such a way so that the same value going into
the attribute isn't the same value coming out of it, then `allow_value`
will balk -- it'll say, "I can't do that because that changes how I
work."
That's all well and good, but what the attribute intentionally changes
incoming values? ActiveRecord's typecasting behavior, for instance,
would trigger such an exception. What if the developer needs a way to
get around this? This is where `ignoring_interference_by_writer` comes
into play. You can tack it on to the end of the matcher, and you're free
to go on your way.
So, prior to this commit you could already apply it to `allow_value`,
but now in this commit it also works on any other matcher.
But, one little thing: sometimes using this qualifier isn't going to
work. Perhaps you or something else actually *is* overriding the
attribute to change incoming values in a specific way, and perhaps the
value that comes out makes the record fail validation, and there's
nothing you can do about it. So in this case, even if you're using
`ignoring_interference_by_writer`, we want to inform you about what the
attribute is doing -- what the input and output was. And so we do.
2015-12-31 01:47:46 +00:00
|
|
|
strict(expects_strict?).
|
|
|
|
ignoring_interference_by_writer(ignore_interference_by_writer)
|
2015-12-14 00:01:14 +00:00
|
|
|
|
|
|
|
yield matcher if block_given?
|
2014-06-27 22:39:39 +00:00
|
|
|
|
|
|
|
matcher
|
2013-03-27 18:13:46 +00:00
|
|
|
end
|
|
|
|
|
2015-12-14 00:01:14 +00:00
|
|
|
def run_allow_or_disallow_matcher(matcher)
|
|
|
|
@last_submatcher_run = matcher
|
|
|
|
matcher.matches?(subject)
|
2012-09-12 00:53:21 +00:00
|
|
|
end
|
2010-12-15 22:34:19 +00:00
|
|
|
end
|
|
|
|
end
|
|
|
|
end
|
2012-03-23 14:50:45 +00:00
|
|
|
end
|