Go: corefunc.ListPush(arr, any)
TF: corefunc_list_push

Push a new item onto the end of a list, mutating the list along the way. Equivalent to Array.push() in JavaScript.

• Go: corefunc.StripCommentsAndSpaces(string)
• TF: corefunc_strip_comments_and_spaces

Idea is to have something that can strip all comments and inner-whitespace from a long, multi-line string. The original use-case is for enabling users to wrap and comment things like regular expressions, then use this to strip all of that stuff back out before passing it to regex(), regexall() or replace() in Terraform.

Regexes should use \s to match spaces instead of using a literal ASCII=20 space character.

Supported comments begin with a #// (space, octothorpe, slash, slash, space — making this up as I go along), and end with an LF or CRLF. This means that it will only support single-line, end-of-line comments.

The goal is not to validate or even execute the regex. The goal is simply compress it into a single line without whitespace or comments without messing it up, and without having to do list/join gymnastics.

Looking for examples both simple and gnarly.

• https://gist.github.com/gruber/8891611
• https://gist.github.com/gruber/249502
• https://daringfireball.net/2010/07/improved_regex_for_matching_urls

Go: corefunc.EnvCopyToVar(envName, tfVarName)
TF: corefunc_env_copy_to_var

Real-world use-case: When integrating PagerDuty and Datadog, need to read PagerDuty API key from PAGERDUTY_TOKEN, then pass it to a variable, so that the Datadog provider can read it without printing in text (which is insecure).

If a Terraform variable is called var.pagerduty_token, then this would read PAGERDUTY_TOKEN and then write that same value to TF_VARS_pagerduty_token so that Terraform will read it as the variable value.

variable "pagerduty_token" {
  description = "PagerDuty API token. Value is set via .env file."
  type        = string
}

data "corefunc_env_copy_to_var" "pagerduty_token" {
  name     = "PAGERDUTY_TOKEN"
  variable = "pagerduty_token"
}

Yes, you could do export TF_VARS_pagerduty_token=$PAGERDUTY_TOKEN, but:

1. You'd be surprised how few people know about this.
2. This (and corefunc_env_ensure) help make it an explicit and unmissable part of running the Terraform.

Go: corefunc.ListPop(array)
TF: corefunc_list_pop_item

Remove and return the last item in a list, mutating the list along the way. Equivalent to Array.pop() in JavaScript.

Go: corefunc.ListLastItem(arr)
TF: corefunc_list_last_item

Gets the last item in a list. Functionally equivalent to list[len(list)-1].

What functionality would you like to see?

Validates whether or not a version meets a constraint. If not, triggers an error.

data "corefunc_semver_constraint" "constraint" {
  version    = "1.2.3-beta.1+build345"
  constraint = ">= 1.2.3, < 2.0.0"
}
#=> Error

If there is an open issue that you want to see implemented, please give the issue a thumbs-up.

The issues list sorted by votes is here:

https://github.com/northwood-labs/terraform-provider-corefunc/issues?q=is%3Aissue+is%3Aopen+sort%3Areactions-%2B1-desc

What functionality would you like to see?

• https://github.com/pelletier/go-toml

What functionality would you like to see?

Some ISO-3166 utilities?

• https://github.com/mikekonan/go-types

What functionality would you like to see?

Same as corefunc_url_parse, but with the stricter Google Safe Browsing profile applied instead.

data "corefunc_url_googlesafe_parse" "url" {
  url = "http://example.com:80/a?b#c"
}

Go: corefunc.StrIterativeReplace(string, []map[string]string)
TF: corefunc_str_iterative_replace

Apply an array of matches/replacements to a string in one batch.

Go: corefunc.ListSortICase(arr)
TF: corefunc_list_sort_icase

Case-insensitive list sorting. Because there are times when order matters.

What functionality would you like to see?

length() counts characters. This should count the individual bytes in those characters.

• https://github.com/mattn/go-runewidth

What functionality would you like to see?

Investigate a smattering of useful date functions.

What functionality would you like to see?

Download assets from GitHub.com/GitHub Enterprise Server.

corefunc_github_assets "trivy" {
  endpoint = "https://api.github.com" # Default value
  token    = var.ghes_token # Use GITHUB_TOKEN for GitHub.com, or GHE_TOKEN for GitHub Enterprise

  repository  = "aquasecurity/trivy"
  version     = "~> 0.40" # Default value is latest
  asset_match = "${OS}-${ARCH}.tar.gz$"
  decompress  = true # Default
  save_as     = "${path}/trivy.tar.gz" # Useful when download is uncompressed binary

  // If you want to simplify the path
  symlink = {
    from = "bin/trivy*",
    to   = "trivy",
  }

  // When current OS is… set ${OS} to…
  set_os_value_when = {
    linux   = "Linux"
    darwin  = "Darwin"
    windows = "Windows"
    solaris = "Solaris"
    freebsd = "FreeBSD"
    openbsd = "OpenBSD"
    netbsd  = "NetBSD"
  }

  // When current CPU architecture is… set ${ARCH} to…
  set_arch_value_when = {
    intel32 = "32bit"
    intel64 = "64bit"
    arm32   = "ARM"
    arm64   = "ARM64"
    ppc32   = "PPC"
    ppc64   = "PPC64LE"
    s390x   = "s390x"
  }
}

Go: corefunc.StrConstant(string)
TF: corefunc_str_constant

A CONSTANT_CASE formatting option.

THIS_IS_CONSTANT_CASE

Is this the right name for this?

What functionality would you like to see?

Ability to push/pull files over SCP.

• https://github.com/appleboy/easyssh-proxy

What functionality would you like to see?

Something that allows users to make HTTP requests beyond simple GET requests.

corefunc_http_request "example" {
  method   = "POST"
  endpoint = "https://example.com/form.php"
  query    = ["q": 1]
  headers  = ["Content-Type": "text/plain"]
  body     = file("${path}/hello.txt")

  timeout_ms  = 2000     # Either this, or timout_sec
  timeout_sec = 2        # Either this, or timout_ms
  min_tls     = "tls1.2" # Default
  ca_cert     = file("${path}/ca-cert.pem")

  error_on_failure     = true            # Default
  success_status       = ">= 100, < 400" # Default
  enable_tracing       = false           # Default
  enable_debug_logging = false           # Default
  follow_redirects     = true            # Default
  retry_algorithm      = "default"       # Default
  retry_max            = 3               # Default

  save_output = "${path}/output.txt"
}

• https://github.com/go-resty/resty
• https://github.com/imroc/req
• https://github.com/opus-domini/fast-shot

Go: corefunc.StrCamel(string)
TF: corefunc_str_camel

A camelCase formatting option.

thisIsCamelCase

What functionality would you like to see?

Coerces a not-quite semantic version into a semantic version.

data "corefunc_semver_coerce" "coersion" {
  version = "1.6"
}
#=> 1.6.0

Go: corefunc.Println(string)
TF: corefunc_println

Print a custom line of text to the plan/apply output.

• Add color support?
• Would support heredocs, of course.

What functionality would you like to see?

• https://github.com/dustin/go-humanize

Go: corefunc.ListSortVersion(arr)
TF: corefunc_list_sort_version

Sorts a list version numbers.

What functionality would you like to see?

Validates whether or not a version meets a constraint.

data "corefunc_semver_constraint" "constraint" {
  version    = "1.2.3-beta.1+build345"
  constraint = ">= 1.2.3, < 2.0.0"
}
#=> false

What functionality would you like to see?

• https://github.com/yuin/goldmark
• https://github.com/yuin/goldmark-highlighting
• https://github.com/yuin/goldmark-emoji
• https://github.com/litao91/goldmark-mathjax
• https://github.com/stephenafamo/goldmark-pdf
• https://github.com/abhinav/goldmark-hashtag
• https://github.com/abhinav/goldmark-wikilink
• https://github.com/abhinav/goldmark-anchor
• https://github.com/mangoumbrella/goldmark-figure
• https://github.com/abhinav/goldmark-frontmatter
• https://github.com/abhinav/goldmark-toc
• https://github.com/abhinav/goldmark-mermaid
• https://github.com/soypat/goldmark-latex
• https://github.com/tenkoh/goldmark-img64
• https://github.com/quail-ink/goldmark-enclave

• https://go.dev/doc/pgo
• https://go.dev/blog/pgo

Thinking we'd do a profile for the Go library by itself, and another profile for the Terraform Provider.

Although profiling tests runs is not likely to be a good long-term source of profiling data for this, it's a cheap-and-easy place to start.

What functionality would you like to see?

Parses a URL according to the rules of the WHATWG URL Specification.

data "corefunc_url_parse" "url" {
  url = "http://example.com:80/a?b#c"
}
#=> {
#  scheme            = "http"
#  host              = "example.com"
#  port              = ""
#  pathname          = "/a"
#  hash              = "#c"
#  fragment          = "c"
#  search            = "?b"
#  query             = "b"
#  normalized        = "http://example.com/a?b#c"
#  normalized_nofrag = "http://example.com/a?b"
# }

What functionality would you like to see?

Sorts a list of versions according to the rules of semver 2.0.

data "corefunc_semver_sort" "versions" {
  versions = ["1.2.3-beta.1+build345", "1.2.3", "0.0.1", "1.5"]
  reverse  = true
}
#=> ["1.5", "1.2.3", "1.2.3-beta.1+build345", "0.0.1"]
```]

https://securityscorecards.dev

What functionality would you like to see?

Validates a version as a semantic version. An invalid version will respond with false.

data "corefunc_semver_validate" "coersion" {
  version = "1.6"
}
#=> false

Inspiration: http://masterminds.github.io/sprig/crypto.html

Inspiration: http://masterminds.github.io/sprig/paths.html

Go: corefunc.StrResolveMarkers(string)
TF: corefunc_str_resolve_markers

The original need was wanting to implement something similar to Late Static Binding where markers could be replaced with values, once those values were determined, as late as possible in the execution process. The replacement values would have been variable/local values.

Terraform does not support this natively.

Need to figure out if we can reflect the current state of all locals/variables in Terraform, and whether or not they are resolved values. If so, we could implement (the very edge-casey) LSB support for string replacements using locals/variables.

If we cannot, then this feature is dead in the water.

Go: corefunc.ListUnshift(arr)
TF: corefunc_list_unshift

Push a new item onto the front of a list, mutating the list along the way. Equivalent to Array.unshift() in JavaScript.

Go: corefunc.ListShift(arr, any)
TF: corefunc_list_shift

Removes and returns the first item in a list, mutating the list along the way. Equivalent to Array.shift() in JavaScript.

Go: corefunc.StrSnake(string)
TF: corefunc_str_snake

A snake_case formatting option.

What functionality would you like to see?

Gets the home directory of the current user.

data "corefunc_homedir_get" "home" {}
#=> /Users/me

• Go: corefunc.Dump(any)
• TF: corefunc_dump

Idea is to have something that can dump the contents of a variable. There are a few things that do this in Go, like gospew. However, I don't think that a straight-up spew of variable internals from Go is the right solution as HCL is a much simpler language with many-fewer constructs.

But I've not yet seen anything that provides this in Terraform other than, maybe, terraform console — which I've never used, but is supposed to be like a REPL for your Terraform state. This is meant to be something that works with Terraform plan, which more users are familiar/comfortable with.

The HCL language is strongly typed under the hood, and in the Terraform Plugin Framework. Not sure if this can be implemented without some sort of generics system, or by supporting any somehow.

Will need to investigate.

Go: corefunc.StrKebab(string)
TF: corefunc_str_kebab

A kebab-case formatting option.

this-is-kebab-case

Inspiration: http://masterminds.github.io/sprig/semver.html

What functionality would you like to see?

Parses a semantic version (coercing if necessary), and provides an object of parts.

data "corefunc_semver_parse" "parse1" {
  version = "1.2.3-beta.1+build345"
}

#=> {
#  major      = 1
#  minor      = 2
#  patch      = 3
#  prerelease = beta.1
#  metadata   = build345
# }

What functionality would you like to see?

Strictly validates a version as a semantic version. An invalid version will trigger an error.

data "corefunc_semver_must_validate" "coersion" {
  version = "1.6"
}
#=> Error

Go: corefunc.StrLeftpad(any, string, length)
TF: corefunc_str_leftpad

Pad the left side of a string with a specified character, a specified number of times.

What functionality would you like to see?

Resolves ~ in a path.

data "corefunc_homedir_expand" "home" {
  path = "~/.aws/"
}
#=> /Users/me/.aws/

What happened?

Fix the implementation of corefunc_str_iterative_replace according to https://developer.hashicorp.com/terraform/plugin/framework/handling-data/blocks/list-nested (which I had not seen before today).

This will fix the bug that is triggered by the LSP server about requiring both a replacements block and attribute.

What functionality would you like to see?

• https://github.com/pelletier/go-toml

What functionality would you like to see?

• https://github.com/clbanning/mxj

Go: corefunc.StrWord(string)
TF: corefunc_str_word

The original idea is to take a string and strip-out any non-word characters (uppercase, lowercase, digits, underscores). Although this idea might need more batting around.

Go: corefunc.StrStudly(string)
TF: corefunc_str_studly

A StudlyCase formatting option. Also known as "PascalCase" or "UpperCamelCase".

ThisIsStudlyCase

Is there a more gender-neutral name for this?

What functionality would you like to see?

• https://github.com/mvdan/xurls