Class: Puppet::Functions::DispatcherBuilder

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

Overview

Public api methods of the DispatcherBuilder are available within dispatch() blocks declared in a Puppet::Function.create_function() call.

Direct Known Subclasses

InternalDispatchBuilder

Instance Attribute Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(dispatcher, all_callables, loader) ⇒ DispatcherBuilder

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 DispatcherBuilder.



398
399
400
401
402
 
# File 'lib/puppet/functions.rb', line 398

def initialize(dispatcher, all_callables, loader)
  @all_callables = all_callables
  @dispatcher = dispatcher
  @loader = loader
end

Instance Attribute Details

#loader ⇒ Object (readonly) 



395
396
397
 
# File 'lib/puppet/functions.rb', line 395

def loader
  @loader
end

Instance Method Details

#block_param(*type_and_name) ⇒ Object Also known as: required_block_param

Defines one required block parameter that may appear last. If type and name is missing the default type is “Callable”, and the name is “block”. If only one parameter is given, then that is the name and the type is “Callable”.



476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
 
# File 'lib/puppet/functions.rb', line 476

def block_param(*type_and_name)
  case type_and_name.size
  when 0
    type = @all_callables
    name = :block
  when 1
    type = @all_callables
    name = type_and_name[0]
  when 2
    type, name = type_and_name
    type = Puppet::Pops::Types::TypeParser.singleton.parse(type, loader) unless type.is_a?(Puppet::Pops::Types::PAnyType)
  else
    raise ArgumentError, _("block_param accepts max 2 arguments (type, name), got %{size}.") % { size: type_and_name.size }
  end

  unless Puppet::Pops::Types::TypeCalculator.is_kind_of_callable?(type, false)
    raise ArgumentError, _("Expected PCallableType or PVariantType thereof, got %{type_class}") % { type_class: type.class }
  end

  unless name.is_a?(Symbol)
    raise ArgumentError, _("Expected block_param name to be a Symbol, got %{name_class}") % { name_class: name.class }
  end

  if @block_type.nil?
    @block_type = type
    @block_name = name
  else
    raise ArgumentError, _('Attempt to redefine block')
  end
end

#optional_block_param(*type_and_name) ⇒ Object

Defines one optional block parameter that may appear last. If type or name is missing the defaults are “any callable”, and the name is “block”. The implementor of the dispatch target must use block = nil when it is optional (or an error is raised when the call is made).



513
514
515
516
517
 
# File 'lib/puppet/functions.rb', line 513

def optional_block_param(*type_and_name)
  # same as required, only wrap the result in an optional type
  required_block_param(*type_and_name)
  @block_type = Puppet::Pops::Types::TypeFactory.optional(@block_type)
end

#optional_param(type, name) ⇒ Void

Defines an optional positional parameter with type and name. May not be followed by a required parameter.

Parameters:

  • type (String) —

    The type specification for the parameter.

  • name (Symbol) —

    The name of the parameter. This is primarily used for error message output and does not have to match an implementation method parameter.

Returns:

  • (Void) 


432
433
434
435
 
# File 'lib/puppet/functions.rb', line 432

def optional_param(type, name)
  internal_param(type, name)
  @max += 1
end

#param(type, name) ⇒ Void Also known as: required_param

Defines a required positional parameter with type and name.

Parameters:

  • type (String) —

    The type specification for the parameter.

  • name (Symbol) —

    The name of the parameter. This is primarily used for error message output and does not have to match an implementation method parameter.

Returns:

  • (Void)

Raises:

  • (ArgumentError) 


413
414
415
416
417
418
419
 
# File 'lib/puppet/functions.rb', line 413

def param(type, name)
  internal_param(type, name)
  raise ArgumentError, _('A required parameter cannot be added after an optional parameter') if @min != @max

  @min += 1
  @max += 1
end

#repeated_param(type, name) ⇒ Void Also known as: optional_repeated_param

Defines a repeated positional parameter with type and name that may occur 0 to “infinite” number of times. It may only appear last or just before a block parameter.

Parameters:

  • type (String) —

    The type specification for the parameter.

  • name (Symbol) —

    The name of the parameter. This is primarily used for error message output and does not have to match an implementation method parameter.

Returns:

  • (Void) 


447
448
449
450
 
# File 'lib/puppet/functions.rb', line 447

def repeated_param(type, name)
  internal_param(type, name, true)
  @max = :default
end

#required_repeated_param(type, name) ⇒ Void

Defines a repeated positional parameter with type and name that may occur 1 to “infinite” number of times. It may only appear last or just before a block parameter.

Parameters:

  • type (String) —

    The type specification for the parameter.

  • name (Symbol) —

    The name of the parameter. This is primarily used for error message output and does not have to match an implementation method parameter.

Returns:

  • (Void)

Raises:

  • (ArgumentError) 


463
464
465
466
467
468
469
 
# File 'lib/puppet/functions.rb', line 463

def required_repeated_param(type, name)
  internal_param(type, name, true)
  raise ArgumentError, _('A required repeated parameter cannot be added after an optional parameter') if @min != @max

  @min += 1
  @max = :default
end

#return_type(type) ⇒ Object

Defines the return type. Defaults to ‘Any’

Parameters:

  • type (String) —

    a reference to a Puppet Data Type



523
524
525
526
527
528
529
 
# File 'lib/puppet/functions.rb', line 523

def return_type(type)
  unless type.is_a?(String) || type.is_a?(Puppet::Pops::Types::PAnyType)
    raise ArgumentError, _("Argument to 'return_type' must be a String reference to a Puppet Data Type. Got %{type_class}") % { type_class: type.class }
  end

  @return_type = type
end