Safe Haskell	None

Puppet.Interpreter.Resolve

Contents

Description

This module is all about converting and resolving foreign data into the fully exploitable corresponding data type. The main use case is the conversion of Expression to PValue.

Synopsis

Pure resolution functions and prisms

_PString :: Prism' PValue Text

A prism between PValue and Text

_PInteger :: Prism' PValue Integer

A prism between PValue and Integer

pvnum :: Prism' PValue Number

A prism between PValue and Number

getVariable

Arguments

:: Container ScopeInformation	The whole scope data.
-> Text	Current scope name.
-> Text	Full variable name.
-> Either Doc PValue

A pure function for resolving variables.

pValue2Bool :: PValue -> Bool

Turns a PValue into a Bool, as explained in the reference documentation.

Monadic resolution functions

resolveVariable :: Text -> InterpreterMonad PValue

Resolves a variable, or throws an error if it can't.

resolveExpression :: Expression -> InterpreterMonad PValue

The main resolution function : turns an Expression into a PValue, if possible.

resolveValue :: UValue -> InterpreterMonad PValue

Resolves an UValue (terminal for the Expression data type) into a PValue

resolvePValueString :: PValue -> InterpreterMonad Text

Turns strings and booleans into Text, or throws an error.

resolveExpressionString :: Expression -> InterpreterMonad Text

 resolveExpressionString = resolveExpression >=> resolvePValueString

resolveExpressionStrings :: Expression -> InterpreterMonad [Text]

Just like resolveExpressionString, but accepts arrays.

resolveArgument :: Pair Text Expression -> InterpreterMonad (Pair Text PValue)

A special helper function for argument like argument like pairs.

runHiera :: Text -> HieraQueryType -> InterpreterMonad (Maybe PValue)

A hiera helper function, that will throw all Hiera errors and log messages to the main monad.

isNativeType :: Text -> InterpreterMonad Bool

A simple helper that checks if a given type is native or a define.

Search expression management

resolveSearchExpression :: SearchExpression -> InterpreterMonad RSearchExpression

Turns an unresolved SearchExpression from the parser into a fully resolved RSearchExpression.

checkSearchExpression :: RSearchExpression -> Resource -> Bool

Checks whether a given Resource matches a RSearchExpression. Note that the expression doesn't check for type, so you must filter the resources by type beforehand, if needs be.

searchExpressionToPuppetDB :: Text -> RSearchExpression -> Query ResourceField

Turns a resource type and RSearchExpression into something that can be used in a PuppetDB query.

Higher order puppet functions handling

hfGenerateAssociations :: HFunctionCall -> InterpreterMonad [[(Text, PValue)]]

Generates variable associations for evaluation of blocks. Each item corresponds to an iteration in the calling block.

hfSetvars :: [(Text, PValue)] -> InterpreterMonad (Container (Pair (Pair PValue PPosition) CurContainerDesc))

Sets the proper variables, and returns the scope variables the way they were before being modified. This is a hack that ensures that variables are local to the new scope.

It doesn't work at all like other Puppet parts, but consistency isn't really expected here ...

hfRestorevars :: Container (Pair (Pair PValue PPosition) CurContainerDesc) -> InterpreterMonad ()

Restores what needs restoring. This will erase all allocations.