Module: Dry::Logic::Predicates::Methods

Included in:
Dry::Logic::Predicates
Defined in:
lib/dry/logic/predicates.rb

Overview

rubocop:disable Metrics/ModuleLength

Constant Summary collapse

UUIDv1 = 
uuid_format(1)
UUIDv2 = 
uuid_format(2)
UUIDv3 = 
uuid_format(3)
UUIDv4 = 
uuid_format(4)
UUIDv5 = 
uuid_format(5)
UUIDv6 = 
uuid_format(6)
UUIDv7 = 
uuid_format(7)
UUIDv8 = 
uuid_format(8)

Class Method Summary collapse

Instance Method Summary collapse

Class Method Details

.uuid_format(version) ⇒ Object 



17
18
19
20
21
 
# File 'lib/dry/logic/predicates.rb', line 17

def self.uuid_format(version)
  ::Regexp.new(<<~FORMAT.chomp, ::Regexp::IGNORECASE)
    \\A[0-9A-F]{8}-[0-9A-F]{4}-#{version}[0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}\\z
  FORMAT
end

Instance Method Details

#[](name) ⇒ Object 



39
40
41
 
# File 'lib/dry/logic/predicates.rb', line 39

def [](name)
  method(name)
end

#array?(input) ⇒ Boolean

Returns:

  • (Boolean) 


87
 
# File 'lib/dry/logic/predicates.rb', line 87

def array?(input) = input.is_a?(::Array)

#attr?(name, input) ⇒ Boolean

Returns:

  • (Boolean) 


50
 
# File 'lib/dry/logic/predicates.rb', line 50

def attr?(name, input) = input.respond_to?(name)

#bool?(input) ⇒ Boolean

Returns:

  • (Boolean) 


63
 
# File 'lib/dry/logic/predicates.rb', line 63

def bool?(input) = input.equal?(true) || input.equal?(false)

#bytesize?(size, input) ⇒ Boolean

Returns:

  • (Boolean) 


114
115
116
117
118
119
120
121
 
# File 'lib/dry/logic/predicates.rb', line 114

def bytesize?(size, input)
  case size
  when ::Integer then size.equal?(input.bytesize)
  when ::Range, ::Array then size.include?(input.bytesize)
  else
    raise ::ArgumentError, "+#{size}+ is not supported type for bytesize? predicate."
  end
end

#case?(pattern, input) ⇒ Boolean

rubocop:disable Style/CaseEquality

Returns:

  • (Boolean) 


170
 
# File 'lib/dry/logic/predicates.rb', line 170

def case?(pattern, input) = pattern === input # rubocop:disable Style/CaseEquality

#date?(input) ⇒ Boolean

Returns:

  • (Boolean) 


65
 
# File 'lib/dry/logic/predicates.rb', line 65

def date?(input) = input.is_a?(::Date)

#date_time?(input) ⇒ Boolean

Returns:

  • (Boolean) 


67
 
# File 'lib/dry/logic/predicates.rb', line 67

def date_time?(input) = input.is_a?(::DateTime)

#decimal?(input) ⇒ Boolean

Returns:

  • (Boolean) 


81
 
# File 'lib/dry/logic/predicates.rb', line 81

def decimal?(input) = input.is_a?(::BigDecimal)

#deprecated(name, in_favor_of) ⇒ Object 



213
214
215
216
217
218
219
220
221
 
# File 'lib/dry/logic/predicates.rb', line 213

def deprecated(name, in_favor_of)
  Core::Deprecations.warn(
    "#{name} predicate is deprecated and will " \
    "be removed in the next major version\n" \
    "Please use #{in_favor_of} predicate instead",
    tag: "dry-logic",
    uplevel: 3
  )
end

#empty?(input) ⇒ Boolean

Returns:

  • (Boolean) 


52
53
54
55
56
57
58
59
 
# File 'lib/dry/logic/predicates.rb', line 52

def empty?(input)
  case input
  when ::String, ::Array, ::Hash then input.empty?
  when nil then true
  else
    false
  end
end

#eql?(left, right = Undefined) ⇒ Boolean

This overrides Object#eql? so we need to make it compatible

Returns:

  • (Boolean) 


154
155
156
157
158
 
# File 'lib/dry/logic/predicates.rb', line 154

def eql?(left, right = Undefined)
  return super(left) if right.equal?(Undefined)

  left.eql?(right)
end

#even?(input) ⇒ Boolean

Returns:

  • (Boolean) 


91
 
# File 'lib/dry/logic/predicates.rb', line 91

def even?(input) = input.even?

#excluded_from?(list, input) ⇒ Boolean

Returns:

  • (Boolean) 


139
 
# File 'lib/dry/logic/predicates.rb', line 139

def excluded_from?(list, input) = !list.include?(input)

#excludes?(value, input) ⇒ Boolean

Returns:

  • (Boolean) 


151
 
# File 'lib/dry/logic/predicates.rb', line 151

def excludes?(value, input) = !includes?(value, input)

#exclusion?(list, input) ⇒ Boolean

Returns:

  • (Boolean) 


132
133
134
135
 
# File 'lib/dry/logic/predicates.rb', line 132

def exclusion?(list, input)
  deprecated(:exclusion?, :excluded_from?)
  excluded_from?(list, input)
end

#false?(value) ⇒ Boolean

Returns:

  • (Boolean) 


166
 
# File 'lib/dry/logic/predicates.rb', line 166

def false?(value) = value.equal?(false)

#filled?(input) ⇒ Boolean

Returns:

  • (Boolean) 


61
 
# File 'lib/dry/logic/predicates.rb', line 61

def filled?(input) = !empty?(input)

#float?(input) ⇒ Boolean

Returns:

  • (Boolean) 


79
 
# File 'lib/dry/logic/predicates.rb', line 79

def float?(input) = input.is_a?(::Float)

#format?(regex, input) ⇒ Boolean

Returns:

  • (Boolean) 


168
 
# File 'lib/dry/logic/predicates.rb', line 168

def format?(regex, input) = !input.nil? && regex.match?(input)

#gt?(num, input) ⇒ Boolean

Returns:

  • (Boolean) 


95
 
# File 'lib/dry/logic/predicates.rb', line 95

def gt?(num, input) = input > num

#gteq?(num, input) ⇒ Boolean

Returns:

  • (Boolean) 


99
 
# File 'lib/dry/logic/predicates.rb', line 99

def gteq?(num, input) = !lt?(num, input)

#hash?(input) ⇒ Boolean

Returns:

  • (Boolean) 


85
 
# File 'lib/dry/logic/predicates.rb', line 85

def hash?(input) = input.is_a?(::Hash)

#included_in?(list, input) ⇒ Boolean

Returns:

  • (Boolean) 


137
 
# File 'lib/dry/logic/predicates.rb', line 137

def included_in?(list, input) = list.include?(input)

#includes?(value, input) ⇒ Boolean

Returns:

  • (Boolean) 


141
142
143
144
145
146
147
148
149
 
# File 'lib/dry/logic/predicates.rb', line 141

def includes?(value, input)
  if input.respond_to?(:include?)
    input.include?(value)
  else
    false
  end
rescue ::TypeError
  false
end

#inclusion?(list, input) ⇒ Boolean

Returns:

  • (Boolean) 


127
128
129
130
 
# File 'lib/dry/logic/predicates.rb', line 127

def inclusion?(list, input)
  deprecated(:inclusion?, :included_in?)
  included_in?(list, input)
end

#int?(input) ⇒ Boolean

Returns:

  • (Boolean) 


77
 
# File 'lib/dry/logic/predicates.rb', line 77

def int?(input) = input.is_a?(::Integer)

#is?(left, right) ⇒ Boolean

Returns:

  • (Boolean) 


160
 
# File 'lib/dry/logic/predicates.rb', line 160

def is?(left, right) = left.equal?(right)

#key?(name, input) ⇒ Boolean

Returns:

  • (Boolean) 


48
 
# File 'lib/dry/logic/predicates.rb', line 48

def key?(name, input) = input.key?(name)

#lt?(num, input) ⇒ Boolean

Returns:

  • (Boolean) 


93
 
# File 'lib/dry/logic/predicates.rb', line 93

def lt?(num, input) = input < num

#lteq?(num, input) ⇒ Boolean

Returns:

  • (Boolean) 


97
 
# File 'lib/dry/logic/predicates.rb', line 97

def lteq?(num, input) = !gt?(num, input)

#max_bytesize?(num, input) ⇒ Boolean

Returns:

  • (Boolean) 


125
 
# File 'lib/dry/logic/predicates.rb', line 125

def max_bytesize?(num, input) = input.bytesize <= num

#max_size?(num, input) ⇒ Boolean

Returns:

  • (Boolean) 


112
 
# File 'lib/dry/logic/predicates.rb', line 112

def max_size?(num, input) = input.size <= num

#min_bytesize?(num, input) ⇒ Boolean

Returns:

  • (Boolean) 


123
 
# File 'lib/dry/logic/predicates.rb', line 123

def min_bytesize?(num, input) = input.bytesize >= num

#min_size?(num, input) ⇒ Boolean

Returns:

  • (Boolean) 


110
 
# File 'lib/dry/logic/predicates.rb', line 110

def min_size?(num, input) = input.size >= num

#nil?(input) ⇒ Boolean Also known as: none?

Returns:

  • (Boolean) 


45
 
# File 'lib/dry/logic/predicates.rb', line 45

def nil?(input) = input.nil?

#not_eql?(left, right) ⇒ Boolean

Returns:

  • (Boolean) 


162
 
# File 'lib/dry/logic/predicates.rb', line 162

def not_eql?(left, right) = !left.eql?(right)

#number?(input) ⇒ Boolean

Returns:

  • (Boolean) 


71
72
73
74
75
 
# File 'lib/dry/logic/predicates.rb', line 71

def number?(input)
  true if Float(input)
rescue ::ArgumentError, ::TypeError
  false
end

#odd?(input) ⇒ Boolean

Returns:

  • (Boolean) 


89
 
# File 'lib/dry/logic/predicates.rb', line 89

def odd?(input) = input.odd?

#predicate(name) ⇒ Object 



209
210
211
 
# File 'lib/dry/logic/predicates.rb', line 209

def predicate(name, &)
  define_singleton_method(name, &)
end

#respond_to?(method, input = Undefined) ⇒ Boolean

This overrides Object#respond_to? so we need to make it compatible

Returns:

  • (Boolean) 


203
204
205
206
207
 
# File 'lib/dry/logic/predicates.rb', line 203

def respond_to?(method, input = Undefined)
  return super if input.equal?(Undefined)

  input.respond_to?(method)
end

#size?(size, input) ⇒ Boolean

Returns:

  • (Boolean) 


101
102
103
104
105
106
107
108
 
# File 'lib/dry/logic/predicates.rb', line 101

def size?(size, input)
  case size
  when ::Integer then size.equal?(input.size)
  when ::Range, ::Array then size.include?(input.size)
  else
    raise ::ArgumentError, "+#{size}+ is not supported type for size? predicate."
  end
end

#str?(input) ⇒ Boolean

Returns:

  • (Boolean) 


83
 
# File 'lib/dry/logic/predicates.rb', line 83

def str?(input) = input.is_a?(::String)

#time?(input) ⇒ Boolean

Returns:

  • (Boolean) 


69
 
# File 'lib/dry/logic/predicates.rb', line 69

def time?(input) = input.is_a?(::Time)

#true?(value) ⇒ Boolean

Returns:

  • (Boolean) 


164
 
# File 'lib/dry/logic/predicates.rb', line 164

def true?(value) = value.equal?(true)

#type?(type, input) ⇒ Boolean

Returns:

  • (Boolean) 


43
 
# File 'lib/dry/logic/predicates.rb', line 43

def type?(type, input) = input.is_a?(type)

#uri?(schemes, input) ⇒ Boolean

Returns:

  • (Boolean) 


189
190
191
192
 
# File 'lib/dry/logic/predicates.rb', line 189

def uri?(schemes, input)
  uri_format = ::URI::RFC2396_PARSER.make_regexp(schemes)
  format?(uri_format, input)
end

#uri_rfc3986?(input) ⇒ Boolean

Returns:

  • (Boolean) 


200
 
# File 'lib/dry/logic/predicates.rb', line 200

def uri_rfc3986?(input) = format?(::URI::RFC3986_Parser::RFC3986_URI, input)

#uuid_v1?(input) ⇒ Boolean

Returns:

  • (Boolean) 


172
 
# File 'lib/dry/logic/predicates.rb', line 172

def uuid_v1?(input) = format?(UUIDv1, input)

#uuid_v2?(input) ⇒ Boolean

Returns:

  • (Boolean) 


174
 
# File 'lib/dry/logic/predicates.rb', line 174

def uuid_v2?(input) = format?(UUIDv2, input)

#uuid_v3?(input) ⇒ Boolean

Returns:

  • (Boolean) 


176
 
# File 'lib/dry/logic/predicates.rb', line 176

def uuid_v3?(input) = format?(UUIDv3, input)

#uuid_v4?(input) ⇒ Boolean

Returns:

  • (Boolean) 


178
 
# File 'lib/dry/logic/predicates.rb', line 178

def uuid_v4?(input) = format?(UUIDv4, input)

#uuid_v5?(input) ⇒ Boolean

Returns:

  • (Boolean) 


180
 
# File 'lib/dry/logic/predicates.rb', line 180

def uuid_v5?(input) = format?(UUIDv5, input)

#uuid_v6?(input) ⇒ Boolean

Returns:

  • (Boolean) 


182
 
# File 'lib/dry/logic/predicates.rb', line 182

def uuid_v6?(input) = format?(UUIDv6, input)

#uuid_v7?(input) ⇒ Boolean

Returns:

  • (Boolean) 


184
 
# File 'lib/dry/logic/predicates.rb', line 184

def uuid_v7?(input) = format?(UUIDv7, input)

#uuid_v8?(input) ⇒ Boolean

Returns:

  • (Boolean) 


186
 
# File 'lib/dry/logic/predicates.rb', line 186

def uuid_v8?(input) = format?(UUIDv8, input)