Class: Puppet::Pops::Functions::Function

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

Overview

Note:

WARNING: This new function API is still under development and may change at any time

A function in the puppet evaluator.

Functions are normally defined by another system, which produces subclasses of this class as well as constructing delegations to call the appropriate methods.

This class should rarely be used directly. Instead functions should be constructed using Functions.create_function.

API:

  • public

Direct Known Subclasses

Functions::Function

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(closure_scope, loader) ⇒ Function

Returns a new instance of Function.

API:

  • public



22
23
24
25
 
# File 'lib/puppet/pops/functions/function.rb', line 22

def initialize(closure_scope, loader)
  @closure_scope = closure_scope
  @loader = loader
end

Instance Attribute Details

#closure_scope ⇒ Object (readonly)

The scope where the function was defined

API:

  • public



15
16
17
 
# File 'lib/puppet/pops/functions/function.rb', line 15

def closure_scope
  @closure_scope
end

#loader ⇒ Object (readonly)

The loader that loaded this function. Should be used if function wants to load other things.

API:

  • public



20
21
22
 
# File 'lib/puppet/pops/functions/function.rb', line 20

def loader
  @loader
end

Class Method Details

.dispatcher ⇒ Object

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.

The dispatcher for the function

API:

  • private



63
64
65
 
# File 'lib/puppet/pops/functions/function.rb', line 63

def self.dispatcher
  @dispatcher ||= Puppet::Pops::Functions::Dispatcher.new
end

.signatures ⇒ Object

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.

Produces information about parameters in a way that is compatible with Closure

API:

  • private



70
71
72
 
# File 'lib/puppet/pops/functions/function.rb', line 70

def self.signatures
  @dispatcher.signatures
end

Instance Method Details

#call(scope, *args, &block) ⇒ Object

Invokes the function via the dispatching logic that performs type check and weaving. A specialized function may override this method to do its own dispatching and checking of the raw arguments. A specialized implementation can rearrange arguments, add or remove arguments and then delegate to the dispatching logic by calling:

System functions that must have access to the calling scope can use this technique. Functions in general should not need the calling scope. (The closure scope; what is visible where the function is defined) is available via the method closure_scope).

Examples:

Delegating to the dispatcher

def call(scope, *args)
  manipulated_args = args + ['easter_egg']
  self.class.dispatcher.dispatch(self, scope, manipulated_args)
end

API:

  • public



43
44
45
 
# File 'lib/puppet/pops/functions/function.rb', line 43

def call(scope, *args, &block)
  self.class.dispatcher.dispatch(self, scope, args, &block)
end

#call_function(function_name, *args, &block) ⇒ Object

Allows the implementation of a function to call other functions by name. The callable functions are those visible to the same loader that loaded this function (the calling function). The referenced function is called with the calling functions closure scope as the caller’s scope.

Parameters:

  • The name of the function

  • splat of arguments

Returns:

  • The result returned by the called function

API:

  • public



56
57
58
 
# File 'lib/puppet/pops/functions/function.rb', line 56

def call_function(function_name, *args, &block)
  internal_call_function(closure_scope, function_name, args, &block)
end