Module: Hegel::Syntax::Methods

Included in:
Generators, Hegel::StateMachine
Defined in:
lib/hegel/syntax/methods.rb,
sig/hegel.rbs

Overview

The generator-constructing methods a caller can include to call bare, matching FactoryBot::Syntax::Methods's shape (see docs/adr/0004):

RSpec.configure { |config| config.include Hegel::Syntax::Methods }

This is the one place any of these methods is defined. Hegel::Generators. reaches the same methods without an include, via Hegel::Generators extending this module below.

Instance Method Summary collapse

Instance Method Details

#arrays(elements, min_size: 0, max_size: nil) ⇒ Generators::ArrayGenerator

An Array of values from elements, with [min_size, max_size] entries.

Parameters:

  • elements (Generator)
  • min_size: (Integer) (defaults to: 0)
  • max_size: (Integer, nil) (defaults to: nil)

Returns:



47
48
49
 
# File 'lib/hegel/syntax/methods.rb', line 47

def arrays(elements, min_size: 0, max_size: nil)
  Generators::ArrayGenerator.new(elements, min_size: min_size, max_size: max_size)
end

#binary(min_size: 0, max_size: nil) ⇒ Generators::BinaryGenerator

A byte String of [min_size, max_size] bytes.

Parameters:

  • min_size: (Integer) (defaults to: 0)
  • max_size: (Integer, nil) (defaults to: nil)

Returns:



95
96
97
 
# File 'lib/hegel/syntax/methods.rb', line 95

def binary(min_size: 0, max_size: nil)
  Generators::BinaryGenerator.new(min_size: min_size, max_size: max_size)
end

#booleans(p: 0.5) ⇒ Generators::BooleanGenerator

A boolean, true with probability p.

Parameters:

  • p: (Float) (defaults to: 0.5)

Returns:



17
18
19
 
# File 'lib/hegel/syntax/methods.rb', line 17

def booleans(p: 0.5)
  Generators::BooleanGenerator.new(p: p)
end

#characters(codec: nil, min_codepoint: nil, max_codepoint: nil) ⇒ Generators::CharactersGenerator

A String of exactly one character, sharing #text's own alphabet options.

Parameters:

  • codec: (String, nil) (defaults to: nil)
  • min_codepoint: (Integer, nil) (defaults to: nil)
  • max_codepoint: (Integer, nil) (defaults to: nil)

Returns:



90
91
92
 
# File 'lib/hegel/syntax/methods.rb', line 90

def characters(codec: nil, min_codepoint: nil, max_codepoint: nil)
  Generators::CharactersGenerator.new(codec: codec, min_codepoint: min_codepoint, max_codepoint: max_codepoint)
end

#composite {|arg0| ... } ⇒ Generators::CompositeGenerator

A value built from imperative code: block receives a draw surface and may call #draw on it any number of times to assemble one value (see Generators::CompositeGenerator).

Yields:

Yield Parameters:

Yield Returns:

  • (Object)

Returns:



157
158
159
 
# File 'lib/hegel/syntax/methods.rb', line 157

def composite(&block)
  Generators::CompositeGenerator.new(&block)
end

#dates(min_value: nil, max_value: nil) ⇒ Generators::DatesGenerator

A proleptic Gregorian calendar Date in [min_value, max_value], defaulting to year 1 through year 9999.

Parameters:

  • min_value: (Object) (defaults to: nil)
  • max_value: (Object) (defaults to: nil)

Returns:



138
139
140
 
# File 'lib/hegel/syntax/methods.rb', line 138

def dates(min_value: nil, max_value: nil)
  Generators::DatesGenerator.new(min_value: min_value, max_value: max_value)
end

#datetimes(min_value: nil, max_value: nil) ⇒ Generators::DatetimesGenerator

A naive (no timezone) Time in [min_value, max_value], defaulting to year 1 through year 9999 (see Generators::DatetimesGenerator).

Parameters:

  • min_value: (Time, nil) (defaults to: nil)
  • max_value: (Time, nil) (defaults to: nil)

Returns:



150
151
152
 
# File 'lib/hegel/syntax/methods.rb', line 150

def datetimes(min_value: nil, max_value: nil)
  Generators::DatetimesGenerator.new(min_value: min_value, max_value: max_value)
end

#deferred ⇒ Generators::DeferredGenerator

A forward reference to a generator whose definition is supplied later via #set, enabling self-recursive and mutually recursive generators (see Generators::DeferredGenerator).

Returns:



164
165
166
 
# File 'lib/hegel/syntax/methods.rb', line 164

def deferred
  Generators::DeferredGenerator.new
end

#domains(max_length: 255) ⇒ Generators::DomainsGenerator

A fully-qualified domain name String of at most max_length characters.

Parameters:

  • max_length: (Integer) (defaults to: 255)

Returns:



118
119
120
 
# File 'lib/hegel/syntax/methods.rb', line 118

def domains(max_length: 255)
  Generators::DomainsGenerator.new(max_length: max_length)
end

#emails ⇒ Generators::EmailsGenerator

An RFC 5321/5322 email address String.

Returns:



107
108
109
 
# File 'lib/hegel/syntax/methods.rb', line 107

def emails
  Generators::EmailsGenerator.new
end

#floats(min_value: nil, max_value: nil, allow_nan: false, allow_infinity: false, exclude_min: false, exclude_max: false) ⇒ Generators::FloatGenerator

A double in [min_value, max_value]. allow_nan and allow_infinity both default to false.

Parameters:

  • min_value: (Float, nil) (defaults to: nil)
  • max_value: (Float, nil) (defaults to: nil)
  • allow_nan: (Boolean) (defaults to: false)
  • allow_infinity: (Boolean) (defaults to: false)
  • exclude_min: (Boolean) (defaults to: false)
  • exclude_max: (Boolean) (defaults to: false)

Returns:



29
30
31
32
33
34
35
 
# File 'lib/hegel/syntax/methods.rb', line 29

def floats(min_value: nil, max_value: nil, allow_nan: false, allow_infinity: false, exclude_min: false,
  exclude_max: false)
  Generators::FloatGenerator.new(
    min_value: min_value, max_value: max_value, allow_nan: allow_nan, allow_infinity: allow_infinity,
    exclude_min: exclude_min, exclude_max: exclude_max
  )
end

#from_regex(pattern, fullmatch: false) ⇒ Generators::FromRegexGenerator

A String matching pattern (Python re syntax, not Ruby's Regexp syntax; see Generators::FromRegexGenerator). fullmatch requires the whole string to match, not just contain a match.

Parameters:

  • pattern (Object)
  • fullmatch: (Boolean) (defaults to: false)

Returns:



102
103
104
 
# File 'lib/hegel/syntax/methods.rb', line 102

def from_regex(pattern, fullmatch: false)
  Generators::FromRegexGenerator.new(pattern, fullmatch: fullmatch)
end

#hashes(keys, values, min_size: 0, max_size: nil) ⇒ Generators::HashGenerator

A Hash whose keys are drawn from keys and values from values, with [min_size, max_size] entries.

Parameters:

  • keys (Generator)
  • values (Generator)
  • min_size: (Integer) (defaults to: 0)
  • max_size: (Integer, nil) (defaults to: nil)

Returns:



84
85
86
 
# File 'lib/hegel/syntax/methods.rb', line 84

def hashes(keys, values, min_size: 0, max_size: nil)
  Generators::HashGenerator.new(keys, values, min_size: min_size, max_size: max_size)
end

#integers(min_value: nil, max_value: nil) ⇒ Generators::IntegerGenerator

An integer in [min_value, max_value], defaulting to the full 64-bit range when either bound is omitted.

Parameters:

  • min_value: (Integer, nil) (defaults to: nil)
  • max_value: (Integer, nil) (defaults to: nil)

Returns:



23
24
25
 
# File 'lib/hegel/syntax/methods.rb', line 23

def integers(min_value: nil, max_value: nil)
  Generators::IntegerGenerator.new(min_value: min_value, max_value: max_value)
end

#ip_addresses(v4: true, v6: true) ⇒ Generators::IpAddressesGenerator

An IPAddr, v4 or v6 depending on +v4+/+v6+ (see Generators::IpAddressesGenerator).

Parameters:

  • v4: (Boolean) (defaults to: true)
  • v6: (Boolean) (defaults to: true)

Returns:



124
125
126
 
# File 'lib/hegel/syntax/methods.rb', line 124

def ip_addresses(v4: true, v6: true)
  Generators::IpAddressesGenerator.new(v4: v4, v6: v6)
end

#just(value) ⇒ Generators::JustGenerator

Always value, drawing nothing.

Parameters:

  • value (Object)

Returns:



52
53
54
 
# File 'lib/hegel/syntax/methods.rb', line 52

def just(value)
  Generators::JustGenerator.new(value)
end

#one_of(*generators) ⇒ Generators::OneOfGenerator

A value drawn from one of generators, picked at random.

Parameters:

Returns:



62
63
64
 
# File 'lib/hegel/syntax/methods.rb', line 62

def one_of(*generators)
  Generators::OneOfGenerator.new(generators)
end

#optional(generator) ⇒ Generators::OptionalGenerator

A value drawn from generator half the time, nil the other half.

Parameters:

Returns:



67
68
69
 
# File 'lib/hegel/syntax/methods.rb', line 67

def optional(generator)
  Generators::OptionalGenerator.new(generator)
end

#sampled_from(collection) ⇒ Generators::SampledFromGenerator

One element of collection, picked at random.

Parameters:

  • collection (Object)

Returns:



57
58
59
 
# File 'lib/hegel/syntax/methods.rb', line 57

def sampled_from(collection)
  Generators::SampledFromGenerator.new(collection)
end

#sets(elements, min_size: 0, max_size: nil) ⇒ Generators::SetGenerator

A Set of values from elements, with [min_size, max_size] entries.

Parameters:

  • elements (Generator)
  • min_size: (Integer) (defaults to: 0)
  • max_size: (Integer, nil) (defaults to: nil)

Returns:



78
79
80
 
# File 'lib/hegel/syntax/methods.rb', line 78

def sets(elements, min_size: 0, max_size: nil)
  Generators::SetGenerator.new(elements, min_size: min_size, max_size: max_size)
end

#text(min_size: 0, max_size: nil, codec: nil, min_codepoint: nil, max_codepoint: nil) ⇒ Generators::TextGenerator

A Unicode string of [min_size, max_size] characters.

Parameters:

  • min_size: (Integer) (defaults to: 0)
  • max_size: (Integer, nil) (defaults to: nil)
  • codec: (String, nil) (defaults to: nil)
  • min_codepoint: (Integer, nil) (defaults to: nil)
  • max_codepoint: (Integer, nil) (defaults to: nil)

Returns:



38
39
40
41
42
43
 
# File 'lib/hegel/syntax/methods.rb', line 38

def text(min_size: 0, max_size: nil, codec: nil, min_codepoint: nil, max_codepoint: nil)
  Generators::TextGenerator.new(
    min_size: min_size, max_size: max_size, codec: codec,
    min_codepoint: min_codepoint, max_codepoint: max_codepoint
  )
end

#times(min_value: nil, max_value: nil) ⇒ Generators::TimesGenerator

A time of day String, "HH:MM:SS.ffffff", in [min_value, max_value] (also "HH:MM:SS.ffffff" Strings), defaulting to the full day.

Parameters:

  • min_value: (String, nil) (defaults to: nil)
  • max_value: (String, nil) (defaults to: nil)

Returns:



144
145
146
 
# File 'lib/hegel/syntax/methods.rb', line 144

def times(min_value: nil, max_value: nil)
  Generators::TimesGenerator.new(min_value: min_value, max_value: max_value)
end

#tuples(*generators) ⇒ Generators::TupleGenerator

An Array holding one value drawn from each of generators, in order (Ruby has no tuple type; see docs/adr/0004).

Parameters:

Returns:



73
74
75
 
# File 'lib/hegel/syntax/methods.rb', line 73

def tuples(*generators)
  Generators::TupleGenerator.new(generators)
end

#urls ⇒ Generators::UrlsGenerator

An RFC 3986 http/https URL String.

Returns:



112
113
114
 
# File 'lib/hegel/syntax/methods.rb', line 112

def urls
  Generators::UrlsGenerator.new
end

#uuids(version: nil) ⇒ Generators::UuidsGenerator

A UUID String in the standard 8-4-4-4-12 hex form. version: nil (the default) draws uniform random bits except the nil UUID; an explicit version forces the RFC 4122 version and variant nibbles (see Generators::UuidsGenerator).

Parameters:

  • version: (Integer, nil) (defaults to: nil)

Returns:



132
133
134
 
# File 'lib/hegel/syntax/methods.rb', line 132

def uuids(version: nil)
  Generators::UuidsGenerator.new(version: version)
end