Module: New::Validation

Included in:
Task
Defined in:
lib/new/validation.rb

Overview

New::Validation is a module for all validation methods

Instance Method Summary collapse

Instance Method Details

#validate_class(value, klass) ⇒ Object 



108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
 
# File 'lib/new/validation.rb', line 108

def validate_class value, klass
  begin
    case
    when klass == String  then String(value)
    when klass == Symbol  then validate_symbol value
    when klass == Boolean then validate_boolean value
    when klass == Integer then Float(value).to_i
    when klass == Float   then Float(value)
    when klass == Array   then value.delete_if{ |v| v == nil || v == '' }
    when klass == Hash    then value.delete_if{ |k, v| v == nil || v == '' || v == [] }
    else value
    end
  rescue
    S.ay "`#{value}` cannot be converted to #{klass}", :error
    raise
  end
end

#validate_option(option_name, option, value) ⇒ Object

validate a task option using a task and its associated options

Parameters:

  • option_name (String) —

    name of an option

  • option (Hash) —

    formatted option object

  • value (String) —

    typically a user-input value

Returns:

  • a valid option value depending on the type/validation rules if no valid value can be made, return nil



12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
 
# File 'lib/new/validation.rb', line 12

def validate_option option_name, option, value
  # validate required option or set default
  if !value || value.empty?
    # if the option is required, raise an error
    if option[:required]
      raise_validation_error option_name, 'is a required option'

    # otherwise set the default
    else
      value = option[:default]
    end
  end

  # set default type
  type = option[:type] || String

  # validate and convert value to specified type
  value = New::Task.validate_class value, type

  # validate with custom validation
  if validation = option[:validation]
    value = case

    when type == String
      validate_regexp option_name, value, validation

    when type == Symbol
      validate_regexp option_name, value, validation

    when type == Integer
      validate_range option_name, value, validation

    when type == Float
      validate_range option_name, value, validation

    when type == Array
      # set default
      validation = validation || String

      # If validation is an array convert it to a hash of String
      if validation.is_a? Array
        validation_hash = {}
        validation.each do |v|
          validation_hash[v] = String
        end
        validation = validation_hash
      end

      # if validation is a hash, make sure all values exist for required keys
      if validation.is_a? Hash
        value.each do |v|
          if validation.keys != v.keys
            raise_validation_error option_name, "validation for an Array must contain values for `#{validation.keys.join(', ')}`"
          end
        end
      else
        unless validation == String || validation == Symbol || validation == Boolean || validation == Integer || validation == Float
          raise_validation_error option_name, "validation for an Array must be a [String|Symbol|Boolean|Integer|Float]"
        end
      end

      # validate each element in array with the validation class type
      value.map! do |v|
        New::Task.validate_class v, validation
      end

      return value

    when type == Hash
      unless validation.is_a?(Array) || validation.is_a?(Hash)
        raise_validation_error option_name, "validation must be an Array or Hash of required keys (Check the New docs for the requirements)"
      end

      # make sure value contains all the required validation keys
      value_keys = (value.is_a?(Array) ? value : value.keys).map(&:to_sym)
      validation_keys = (validation.is_a?(Array) ? validation : validation.keys).map(&:to_sym)
      unless (validation_keys & value_keys) == validation_keys
        raise_validation_error option_name, "must contain all the following keys: #{validation_keys.join(', ')}"
      end

      # make sure values are of the provided class type
      if validation.is_a? Hash
        validation.each do |key, klass|
          value[key] = New::Task.validate_class value[key], klass
        end
      end

      return value
    else
      return value
    end
  end

  return value
end