Module: Quick::Sampler::DSL::SimpleCombinators

Included in:
Quick::Sampler::DSL
Defined in:
lib/quick/sampler/dsl/simple_combinators.rb

Overview

DSL methods that allow to combine samplers in various ways.

Recursive samplers

Some of the combinators are recursive: given a nested structure of Arrays and Hashes containing samplers and non-sampler values they would produce an analogous structure where samplers are replaced by their #next value.

Instance Method Summary collapse

Instance Method Details

#list_like(*args) ⇒ Quick::Sampler

Sampler of arbitrary nested structures made up of Arrays, Hashes, Quick::Samplers and non-sampler values

Parameters:

  • args (Array) —

    a template structure

Returns:



86
87
88
 
# File 'lib/quick/sampler/dsl/simple_combinators.rb', line 86

def list_like *args
  feed { args.map { |arg| recursive_sample(arg) } }
end

#list_of(sampler, non_empty: false) ⇒ Quick::Sampler

Sampler of uniform arrays

This sampler honors upper_bound config variable and samples Arrays of up to that many elements.

Rosetta stone the single argument version corresponds to QuickCheck's listOf. Passing non_empty: true turns it into QuickCheck's listOf1.

Parameters:

  • sampler (Quick::Sampler) —

    a sampler to sample array elements from

  • non_empty (Boolean) (defaults to: false) —

    pass true to never produce empty arrays

Returns:

  • (Quick::Sampler) —

    a sampler that produces arrays of values sampled from its argument



60
61
62
63
 
# File 'lib/quick/sampler/dsl/simple_combinators.rb', line 60

def list_of sampler, non_empty: false
  lower_bound = non_empty ? 1 : 0
  feed { sampler.first(rand(lower_bound..upper_bound)) }
end

#one_of(*args) ⇒ Quick::Sampler

Returns a sampler that recursively samples on of the arguments at random.

Returns:

  • (Quick::Sampler) —

    a sampler that recursively samples on of the arguments at random



25
26
27
 
# File 'lib/quick/sampler/dsl/simple_combinators.rb', line 25

def one_of *args
  feed { recursive_sample(args.sample) }
end

#one_of_weighted(expression_weights) ⇒ Quick::Sampler

Returns a sampler that recursively samples on of the expressions at random, with likelyhood of picking one of the expressions depends on its weight.

Returns:

  • (Quick::Sampler) —

    a sampler that recursively samples on of the expressions at random, with likelyhood of picking one of the expressions depends on its weight.



32
33
34
35
36
37
38
39
40
41
42
43
44
 
# File 'lib/quick/sampler/dsl/simple_combinators.rb', line 32

def one_of_weighted expression_weights
  total_weight, expressions = expression_weights
    .reduce([0, {}]) { |(total_weight, expressions), (expression, weight)|
      total_weight += weight
      [total_weight, expressions.merge(total_weight => expression)]
    }

  feed {
    dice = rand * total_weight
    weight_class = expressions.keys.find{|w| dice < w}
    recursive_sample(expressions[weight_class])
  }
end

#pick_from(source) ⇒ Quick::Sampler

Returns a sampler producing values from the range or array.

Returns:

  • (Quick::Sampler) —

    a sampler producing values from the range or array



14
15
16
17
18
19
20
21
 
# File 'lib/quick/sampler/dsl/simple_combinators.rb', line 14

def pick_from source
  case source
  when Range
    feed { rand(source) }
  when Array
    feed { source.sample }
  end
end

#send_to(recipient, message, *args) ⇒ Quick::Sampler #send_to(sampler) ⇒ Quick::Sampler

Sampler of arbitrary message send ("method call") results

Overloads:

  • #send_to(recipient, message, *args) ⇒ Quick::Sampler

    Parameters:

    • recipient (Object, Quick::Sampler<Object>) —

      message recipient or a sampler producing recipients

    • message (Symbol, Quick::Sampler<Symbol>) —

      message to send or a sampler producing messages

    • args (Array) —

      argument list that may contain samplers producing arguments

  • #send_to(sampler) ⇒ Quick::Sampler

    Parameters:

    • sampler (Quick::Sampler<[Object, Symbol, *Anything]>) —

      a sampler producing the message send details

Returns:

  • (Quick::Sampler) —

    a sampler of dynamically generated message send results



106
107
108
109
110
111
112
113
114
115
116
 
# File 'lib/quick/sampler/dsl/simple_combinators.rb', line 106

def send_to *args
  call_sampler = if args.count > 1
                   list_like *args
                 else
                   args.first
                 end
  feed {
    object, message, *args = call_sampler.next
    object.send( message, *args )
  }
end

#vector_of(length, sampler) ⇒ Quick::Sampler

Sampler of uniform fixed length arrays

Rosetta stone this sampler corresponds to QuickCheck's vectorOf.

Parameters:

  • length (Integer) —

    sample array length

  • sampler (Quick::Sampler) —

    a sampler to sample array elements from

Returns:

  • (Quick::Sampler) —

    a sampler that produces arrays of length of values sampled from sampler



75
76
77
 
# File 'lib/quick/sampler/dsl/simple_combinators.rb', line 75

def vector_of length, sampler
  feed { sampler.take(length).force }
end