Class: Aspect::Verifier

Inherits:
Object
  • Object
show all
Includes:
HasAttributes
Defined in:
lib/aspect/verifier.rb,
lib/aspect/verifier/check.rb

Overview

Verify a set of checks on an object.

The result is a ‘Hash` where the keys are the check name and the value is the expectation or `nil` when the object is verified to be valid.

This allows for it to easily be transformed into messages using MessageTransform, if needed.

Examples:

Simple boolean checks.

require "aspect/verifier"

verifier = Aspect::Verifier.new(:presence, :integer)

verifier.verify(nil)     # => { presence: true, integer: true } # Invalid
verifier.verify("")      # => { presence: true, integer: true } # Invalid
verifier.verify("hello") # => { integer: true }                 # Invalid
verifier.verify("24")    # => nil                               # Valid

Simple checks with arguments.

require "aspect/verifier"

verifier = Aspect::Verifier.new(integer: true, greater_than: 10)

verifier.verify(10) # => { greater_than: 10 }                     # Invalid
verifier.verify("hello") # => { integer: true, greater_than: 10 } # Invalid
verifier.verify("24") # => nil                                    # Valid

Break on fail.

require "aspect/verifier"

verifier = Aspect::Verifier.new(integer: true, greater_than: 10)

verifier.verify("hello") # => { integer: true, greater_than: 10 }
verifier.verify("hello", break_on_fail: true) # => { integer: true }

Fake application usage example

require "aspect/verifier"

age_verifier = Aspect::Verifier.new(:integer, greater_than_or_equal_to: 18)

loop do
  print "age? "

  input = gets
  error = age_verifier.verify(input, break_on_fail: true)

  if error
    puts "  Must give a number." if error[:integer]
    puts "  Must be #{error[:greater_than_or_equal_to]} or older." if error[:greater_than_or_equal_to]
  else
    puts "  Welcome, appropriately-aged user!"

    break
  end
end

# Command line:
#   age? foobar
#     Must give a number.
#   age? 17
#     Must be 18 or older.
#   age? 25
#     Welcome, appropriately-aged user!

Fake application usage example with MessageTransform

require "aspect/verifier"
require "aspect/message_transform"

age_verifier = Aspect::Verifier.new(:integer, greater_than_or_equal_to: 18)
message = Aspect::MessageTransform.new(
  welcome: "Welcome, appropriately-aged user!",
  error: {
    integer: "Must give a number.",
    greater_than_or_equal_to: "Must be %{greater_than_or_equal_to} or older."
  }
)

loop do
  print "age? "

  input = gets
  error = age_verifier.verify(input, break_on_fail: true)

  print "  "
  if error
    puts message.to_s(error: error)
  else
    puts message.to_s(:welcome)

    break
  end
end

# Command line:
#   age? foobar
#     Must give a number.
#   age? 17
#     Must be 18 or older.
#   age? 25
#     Welcome, appropriately-aged user!

Defined Under Namespace

Classes: Check

Instance Method Summary collapse

Methods included from HasAttributes

included, #update_attributes

Constructor Details

#initialize(*arguments) ⇒ Verifier

Returns a new instance of Verifier.

Examples:

Multiple flags, for boolean checks.

Aspect::Verifier.new(:presence, :integer)

‘Array` of flags, for boolean checks.

Aspect::Verifier.new([:presence, :integer])

Passing a ‘Hash`, for non-boolean checks.

Aspect::Verifier.new(presence: true, integer: true, greater_than: 10)

Mixing both boolean and non-boolean checks.

Aspect::Verifier.new(:presence, :integer, greater_than: 10)


113
114
115
116
117
118
119
120
121
122
123
124
125
 
# File 'lib/aspect/verifier.rb', line 113

def initialize(*arguments)
  attributes = {}

  if arguments.length == 1 && arguments[0].respond_to?(:to_h)
    attributes = arguments[0]
  else
    arguments = arguments[0] if arguments.length == 1 && arguments[0].is_a?(Array)

    arguments.collect(&:to_sym).each { |check| attributes[check] = true }
  end

  update_attributes(attributes)
end

Instance Method Details

#equal_to ⇒ Boolean

Get whether to for equality against a given object.

Returns:

  • (Boolean) 


200
 
# File 'lib/aspect/verifier.rb', line 200

attribute(:equal_to)

#equal_to= ⇒ nil, Object

Set the object to check equality against.

Parameters:

  • value (nil, Object)

Returns:

  • (nil, Object) 



# File 'lib/aspect/verifier.rb', line 190

#float= ⇒ Boolean

Set whether to check for ‘Float`.

The values ‘123.4` and `“123.4”` will both pass.

Parameters:

  • value (Boolean)

Returns:

  • (Boolean) 



# File 'lib/aspect/verifier.rb', line 176

#float? ⇒ Boolean

Get whether to check for ‘Float`.

Returns:

  • (Boolean) 


188
 
# File 'lib/aspect/verifier.rb', line 188

attribute(:float, query: true)

#integer= ⇒ Boolean

Set whether to check for ‘Integer`.

The values ‘123` and `“123”` will both pass, but `123.4` and `“123.4”` will both fail.

Parameters:

  • value (Boolean)

Returns:

  • (Boolean) 



# File 'lib/aspect/verifier.rb', line 162

#integer? ⇒ Boolean

Get whether to check for ‘Integer`.

Returns:

  • (Boolean) 


174
 
# File 'lib/aspect/verifier.rb', line 174

attribute(:integer, query: true)

#presence= ⇒ Boolean

Set whether to check for presence.

Objects that are ‘nil`, or respond to `empty?` and return `true`, are considered blank.

Parameters:

  • value (Boolean)

Returns:

  • (Boolean) 



# File 'lib/aspect/verifier.rb', line 148

#presence? ⇒ Boolean

Get whether to check for presence.

Returns:

  • (Boolean) 


160
 
# File 'lib/aspect/verifier.rb', line 160

attribute(:presence, query: true)

#validate(value, options = {}) ⇒ <Symbol, Object>

Validate a value.

Parameters:

  • value
  • options (#to_h) (defaults to: {})

Options Hash (options):

  • :break_on_fail (Boolean) —

    Set to ‘true` to stop running checks as soon as one fails.

Returns:

  • (<Symbol, Object>) —

    The result is a ‘Hash` where the keys are the check name and the value is the expectation or `nil` when the object is verified to be valid.



133
134
135
136
137
138
139
140
141
142
143
144
145
146
 
# File 'lib/aspect/verifier.rb', line 133

def validate(value, options={})
  options = { break_on_fail: false }.merge(options.to_h)
  errors = {}

  Check.registry.each do |check_name, check|
    check_iv = instance_variable_get("@#{check_name}")

    errors[check_name] = check_iv if check_iv && !check.call(value, check_iv)

    break if options[:break_on_fail]
  end

  errors
end