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.

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.



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



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.



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



85
86
87
 
# File 'lib/puppet/pops/functions/function.rb', line 85

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



92
93
94
 
# File 'lib/puppet/pops/functions/function.rb', line 92

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


43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
 
# File 'lib/puppet/pops/functions/function.rb', line 43

def call(scope, *args, &block)
  begin
    result = catch(:return) do
      return self.class.dispatcher.dispatch(self, scope, args, &block)
    end
    return result.value
  rescue Puppet::Pops::Evaluator::Next => jumper
    begin
      throw :next, jumper.value
    rescue Puppet::Parser::Scope::UNCAUGHT_THROW_EXCEPTION => uncaught
      raise Puppet::ParseError.new("next() from context where this is illegal", jumper.file, jumper.line)
    end
  rescue Puppet::Pops::Evaluator::Return => jumper
    begin
      throw :return, jumper
    rescue Puppet::Parser::Scope::UNCAUGHT_THROW_EXCEPTION => uncaught
      raise Puppet::ParseError.new("return() from context where this is illegal", jumper.file, jumper.line)
    end
  end
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:

  • function_name (String) —

    The name of the function

  • *args (Object) —

    splat of arguments

Returns:

  • (Object) —

    The result returned by the called function



73
74
75
 
# File 'lib/puppet/pops/functions/function.rb', line 73

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