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

#hash_like(template) ⇒ Quick::Sampler<Hash>

Sampler of hashe's that in turn may contain Arrays, Hashes and Quick::Samplers.

Parameters:

  • pattern (Hash) —

    a hash that will be used as a template for samples

Returns:



89
90
91
 
# File 'lib/quick/sampler/dsl/simple_combinators.rb', line 89

def hash_like template
  send_to list_like(template), :first
end

#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:



80
81
82
 
# File 'lib/quick/sampler/dsl/simple_combinators.rb', line 80

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

#list_of(sampler, size: 1..10) ⇒ Quick::Sampler

Sampler of uniform arrays

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

Returns:

  • (Quick::Sampler) —

    a sampler that produces arrays of values sampled from its argument



55
56
57
 
# File 'lib/quick/sampler/dsl/simple_combinators.rb', line 55

def list_of sampler, size: 1..10
  send_to(sampler, :first, size)
end

#object_like(the_class, *args) ⇒ Object

Arbitrary object sampler.

Parameters:

  • the_class (Class, Quick::Sampler<Class>) —

    a class of the object to create (or a sampler producing classes)

  • *args (*Anything) —

    arguments to pass to the constructor (may contain samplers)



127
128
129
 
# File 'lib/quick/sampler/dsl/simple_combinators.rb', line 127

def object_like the_class, *args
  send_to(the_class, :new, *args)
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) }
  else
    feed { source.to_a.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



109
110
111
112
113
114
115
116
117
118
119
 
# File 'lib/quick/sampler/dsl/simple_combinators.rb', line 109

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(size, sampler) ⇒ Quick::Sampler

Sampler of uniform fixed size arrays

Rosetta stone this sampler corresponds to QuickCheck's vectorOf.

Parameters:

  • size (Integer) —

    sample array size

  • sampler (Quick::Sampler) —

    a sampler to sample array elements from

Returns:

  • (Quick::Sampler) —

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



69
70
71
 
# File 'lib/quick/sampler/dsl/simple_combinators.rb', line 69

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