Class: Puppet::Pal::FunctionSignature

Inherits:
Object
  • Object
show all
Defined in:
lib/puppet/pal/function_signature.rb

Overview

A FunctionSignature is returned from ‘function_signature`. Its purpose is to answer questions about the function’s parameters and if it can be called with a set of parameters.

It is also possible to get an array of puppet Callable data type where each callable describes one possible way the function can be called.

Instance Method Summary collapse

Constructor Details

#initialize(function_class) ⇒ FunctionSignature

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future.

Returns a new instance of FunctionSignature.



15
16
17
 
# File 'lib/puppet/pal/function_signature.rb', line 15

def initialize(function_class)
  @func = function_class
end

Instance Method Details

#callable_with?(args, callable = nil) {|String| ... } ⇒ Boolean

Returns true if the function can be called with the given arguments and false otherwise. If the function is not callable, and a code block is given, it is given a formatted error message that describes the type mismatch. That error message can be quite complex if the function has multiple dispatch depending on given types.

Parameters:

  • args (Array) —

    The arguments as given to the function call

  • callable (Proc, nil) (defaults to: nil) —

    An optional ruby Proc or puppet lambda given to the function

Yields:

  • (String) —

    a formatted error message describing a type mismatch if the function is not callable with given args + block

Returns:

  • (Boolean) —

    true if the function can be called with given args + block, and false otherwise



30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/puppet/pal/function_signature.rb', line 30

def callable_with?(args, callable = nil)
  signatures = @func.dispatcher.to_type
  callables = signatures.is_a?(Puppet::Pops::Types::PVariantType) ? signatures.types : [signatures]

  return true if callables.any? { |t| t.callable_with?(args) }
  return false unless block_given?

  args_type = Puppet::Pops::Types::TypeCalculator.singleton.infer_set(callable.nil? ? args : args + [callable])
  error_message = Puppet::Pops::Types::TypeMismatchDescriber.describe_signatures(@func.name, @func.signatures, args_type)
  yield error_message
  false
end

#callables ⇒ Array<Puppet::Pops::Types::PCallableType] one callable per way the function can be called

Returns an array of Callable puppet data type

Returns:

  • (Array<Puppet::Pops::Types::PCallableType] one callable per way the function can be called) —

    Array<Puppet::Pops::Types::PCallableType] one callable per way the function can be called



48
49
50
51
 
# File 'lib/puppet/pal/function_signature.rb', line 48

def callables
  signatures = @func.dispatcher.to_type
  signatures.is_a?(Puppet::Pops::Types::PVariantType) ? signatures.types : [signatures]
end