Class: Puppet::Pops::Evaluator::Closure

Inherits:
CallableSignature show all
Defined in:
lib/puppet/pops/evaluator/closure.rb

Overview

A Closure represents logic bound to a particular scope. As long as the runtime (basically the scope implementation) has the behavior of Puppet 3x it is not safe to return and later use this closure.

The 3x scope is essentially a named scope with an additional internal local/ephemeral nested scope state. In 3x there is no way to directly refer to the nested scopes, instead, the named scope must be in a particular state. Specifically, closures that require a local/ephemeral scope to exist at a later point will fail. It is safe to call a closure (even with 3x scope) from the very same place it was defined, but not returning it and expecting the closure to reference the scope’s state at the point it was created.

Note that this class is a CallableSignature, and the methods defined there should be used as the API for obtaining information in a callable-implementation agnostic way.

Direct Known Subclasses

Dynamic, Named

Defined Under Namespace

Classes: Dynamic, Named

Constant Summary collapse

CLOSURE_NAME = 
'lambda'.freeze

Instance Attribute Summary collapse

Instance Method Summary collapse

Methods inherited from CallableSignature

#args_range, #argument_mismatch_handler?, #block_range, #block_type, #infinity?

Constructor Details

#initialize(evaluator, model) ⇒ Closure

Returns a new instance of Closure.



60
61
62
63
 
# File 'lib/puppet/pops/evaluator/closure.rb', line 60

def initialize(evaluator, model)
  @evaluator = evaluator
  @model = model
end

Instance Attribute Details

#enclosing_scope ⇒ Object (readonly) 



58
59
60
 
# File 'lib/puppet/pops/evaluator/closure.rb', line 58

def enclosing_scope
  @enclosing_scope
end

#evaluator ⇒ Object (readonly) 



56
57
58
 
# File 'lib/puppet/pops/evaluator/closure.rb', line 56

def evaluator
  @evaluator
end

#model ⇒ Object (readonly) 



57
58
59
 
# File 'lib/puppet/pops/evaluator/closure.rb', line 57

def model
  @model
end

Instance Method Details

#block_name ⇒ Object 



161
162
163
164
 
# File 'lib/puppet/pops/evaluator/closure.rb', line 161

def block_name
  # TODO: Lambda's does not support blocks yet. This is a placeholder
  'unsupported_block'
end

#call(*args) ⇒ Object

Evaluates a closure in its enclosing scope after having matched given arguments with parameters (from left to right)



67
68
69
 
# File 'lib/puppet/pops/evaluator/closure.rb', line 67

def call(*args)
  call_with_scope(enclosing_scope, args)
end

#call_by_name(args_hash, enforce_parameters) ⇒ Object 



85
86
87
 
# File 'lib/puppet/pops/evaluator/closure.rb', line 85

def call_by_name(args_hash, enforce_parameters)
  call_by_name_internal(enclosing_scope, args_hash, enforce_parameters)
end

#call_by_name_with_scope(scope, args_hash, enforce_parameters) ⇒ Object 



81
82
83
 
# File 'lib/puppet/pops/evaluator/closure.rb', line 81

def call_by_name_with_scope(scope, args_hash, enforce_parameters)
  call_by_name_internal(scope, args_hash, enforce_parameters)
end

#closure_name ⇒ Object 



169
170
171
 
# File 'lib/puppet/pops/evaluator/closure.rb', line 169

def closure_name()
  CLOSURE_NAME
end

#invoke(instance, calling_scope, args, &block) ⇒ 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.

This method makes a Closure compatible with a Dispatch. This is used when the closure is wrapped in a Function and the function is called. (Saves an extra Dispatch that just delegates to a Closure and avoids having two checks of the argument type/arity validity).



75
76
77
78
79
 
# File 'lib/puppet/pops/evaluator/closure.rb', line 75

def invoke(instance, calling_scope, args, &block)
  enclosing_scope.with_global_scope do |global_scope|
    call_with_scope(global_scope, args, &block)
  end
end

#last_captures_rest? ⇒ Boolean

Returns:

  • (Boolean) 


155
156
157
158
 
# File 'lib/puppet/pops/evaluator/closure.rb', line 155

def last_captures_rest?
  last = @model.parameters[-1]
  last && last.captures_rest
end

#parameter_count ⇒ Integer

Returns the number of parameters (required and optional)

Returns:

  • (Integer) —

    the total number of accepted parameters



130
131
132
133
 
# File 'lib/puppet/pops/evaluator/closure.rb', line 130

def parameter_count
  # yes, this is duplication of code, but it saves a method call
  @model.parameters.size
end

#parameter_names ⇒ Object 



136
137
138
 
# File 'lib/puppet/pops/evaluator/closure.rb', line 136

def parameter_names
  @model.parameters.collect(&:name)
end

#parameters ⇒ Object 



124
125
126
 
# File 'lib/puppet/pops/evaluator/closure.rb', line 124

def parameters
  @model.parameters
end

#params_struct ⇒ Object 



150
151
152
 
# File 'lib/puppet/pops/evaluator/closure.rb', line 150

def params_struct
  @params_struct ||= create_params_struct
end

#return_type ⇒ Object 



140
141
142
 
# File 'lib/puppet/pops/evaluator/closure.rb', line 140

def return_type
  @return_type ||= create_return_type
end

#type ⇒ Object 



145
146
147
 
# File 'lib/puppet/pops/evaluator/closure.rb', line 145

def type
  @callable ||= create_callable_type
end