scripts/Interpolate-Item.ps1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
function Interpolate-Item {
  [CmdletBinding()]
  param (
    [Parameter(Position = 0, Mandatory = $true, ValueFromPipeline = $true)]
    [object]$item,

    [Parameter(Mandatory = $false)]
    [hashtable]$step = @{},

    [Parameter(Mandatory = $false)]
    [hashtable]$config = (Coalesce (Peek-Config), @{}),

    [Parameter(Mandatory = $false)]
    [object[]]$rules = @(@{'\[\[\$\((?<eval>.*?)\)\]\]'=''},
      @{'\[\[\.(?<eval>.*?)\]\]'='$context.'})
  )
  process {
    "Interpolate-Item:In:$(@{'$_'=$_} | ConvertTo-Yaml)" | f-log-dbg
    "Interpolate-Item:In:$(@{'$step'=$step} | ConvertTo-Yaml)" | f-log-dbg

    if (-not $item) {
      return $step
    }

    $context_tmp = $step['$context']
    if ($context_tmp) { $step.Remove('$context') }

    if (($item.GetType() -match 'HashtableEnumerator') `
        -or ($item -is [Collections.DictionaryEntry])) {
      $item = $item | ForEach-Object { @{Key = $_.Key; Value = $_.Value } }
    }

    $context = $step
    if ($item -is [hashtable]) {
      $context = Merge-Hashtables $step $item
    }
    $context = $context | Interpolate-Evals
    "Interpolate-Item:Build-Context:$(@{'$context'=$context} | ConvertTo-Yaml)" | f-log-dbg

    try {
      $json = $context | ConvertTo-Json -Depth 99
      "Interpolate-Item:Merge:`$json = $json" | f-log-dbg
      $counter = 0
      foreach ($regex in $rules.Keys) {
        while ($json -match $regex) {
          "Interpolate-Item:$(@{'$matches'=$matches} | ConvertTo-Yaml)" | f-log-dbg
          $subst = $matches.0
          $eval = $matches.eval
          if (-not $eval) {
            if ($item -is [hashtable]){
              $value = $context | f-subtract -s $step
            } else {
              $value = $item
            }
          }
          else {
            $eval = ConvertFrom-Json "`"$($rules.$($regex))$eval`""
            $value = Invoke-Expression $eval
          }
          if ($value -isnot [string]) {
            # assign complex values via json
            $value = $value | ConvertTo-Json -Depth 99
            "Interpolate-Item:Out:ConvertTo-Json:`$value = $value" | f-log-dbg
            # it might be former string, so:
            $json = $json.Replace("`"$subst`"", $value)
          }
          else {
            $value = $value | f-escape-json
          }
          "Interpolate-Item:Replace:In:`n$(@{subst=`"$subst`";eval=`"$eval`";value=`"$value`"} | ConvertTo-Yaml)" | f-log-dbg
          $json = $json.Replace($subst, $value)
          "Interpolate-Item:Replace:Out:$(@{'$json'=`"$json`"} | ConvertTo-Yaml)" | f-log-dbg

          if ($counter++ -ge ${global:pwshake-context}.options.max_depth) {
            throw "Circular reference detected for evaluations: $($regex.Matches($json) | Sort-Object -Property Value)"
          }

          $context = $json | ConvertFrom-Yaml
        }
      }
      "Interpolate-Item:Loop-Out:$(@{'$context'=$context} | ConvertTo-Yaml)" | f-log-dbg
    }
    finally {
      if ($context_tmp) { $context['$context'] = $context_tmp }
      if ($step.Keys.Count) {
        $item.Keys | f-null | ForEach-Object { $context.Remove($_) }
      }
    }

    "Interpolate-Item:Out:$(@{'$context'=$context} | ConvertTo-Yaml)" | f-log-dbg
    return $context
  }
}