Suggestions about arguments escaping and quoting

[pizzafroide]

Even though my examples are all about PowerShell, I guess some kind of similar mechanism would be usefull for bash too...

Verbatim strings, expandable strings, and here-strings

For now, quotePowerShell function escapes values using verbatim strings. But wouldn't it be more relavant to use expandable strings instead? And also, use here-strings for multiline input?

For example, the following code does not work as expected (meaning the output won't be blue) unless $.quote is redefined:

import { usePwsh } from 'zx'

usePwsh()

await $`Write-Host ${'$($PSStyle.Foreground.Blue)This should be blue!$($PSStyle.Reset)'}`

Note that the $.quote function is pretty easy to implement:

$.quote = (arg) => {
  if (arg.indexOf('\n') !== -1) return `@"\n${arg}\n"@`
  return /^[a-z0-9/_.\-]+$/i.test(arg) || arg === ''
    ? arg
    : `"${arg.replace(/"/g, '`"')}"`
}

But I guess it would be event better if usePowerShell and usePwsh functions allowed to select which kind of strings should be used by default. Something like:

usePwsh({ quote: 'expandable' })

More control over escaping and quoting

IMHO, it would also be interesting to let the user have control over escaping and quoting mechanism at the "argument" level. zx could export some functions to do so:

import { usePwsh, expandable } from 'zx'

usePwsh()

await $`Write-Host ${expandable(
  '$($PSStyle.Foreground.Blue)This should be blue!$($PSStyle.Reset)'
)}`

Working example

Here is a working example (with an awfull hack, though) illustrating what I mean:

import assert from 'node:assert'

const verbatimQuote = (arg) => {
  if (arg.indexOf('\n') !== -1) return `@'\n${arg}\n'@`
  return /^[a-z0-9/_.\-]+$/i.test(arg) || arg === ''
    ? arg
    : `'${arg.replace(/'/g, "''")}'`
}

const expandableQuote = (arg) => {
  if (arg.indexOf('\n') !== -1) return `@"\n${arg}\n"@`
  return /^[a-z0-9/_.\-]+$/i.test(arg) || arg === ''
    ? arg
    : `"${arg.replace(/"/g, '`"')}"`
}

let defaultQuote = verbatimQuote

const usePwsh = ({ quote } = { quote: 'verbatim' }) => {
  $.shell = which.sync('pwsh.exe')
  $.prefix = ''
  $.postfix = '; exit $LastExitCode'
  switch (quote) {
    case 'verbatim':
      defaultQuote = verbatimQuote
      break
    case 'expandable':
      defaultQuote = expandableQuote
      break
  }
}

class Quote {
  quote

  string

  constructor(q, s) {
    switch (q) {
      case 'verbatim':
        this.quote = verbatimQuote
        break
      case 'expandable':
        this.quote = expandableQuote
        break
      default:
        assert(typeof q === 'function')
        this.quote = q
        break
    }
    this.string = s
  }

  // This is an awfull hack that should be replaced by an evolution of the 'substitute' function in zurk:
  //
  // ```js
  // export const substitute = (arg) =>
  //   typeof arg && arg.stdout === 'string'
  //     ? arg.stdout.replace(/\n$/, '')
  //     : arg instanceof Quote
  //     ? arg
  //     : `${arg}`
  // ```
  static MARK = 'QUOTE_MARK_HACK'

  static isQuoted(s) {
    return s.startsWith(Quote.MARK)
  }

  static get(s) {
    return s.substring(Quote.MARK.length)
  }

  static mark(s) {
    return `${Quote.MARK}${s}`
  }

  toString() {
    return Quote.mark(this.quote(this.string))
  }
}

$.quote = (arg) => {
  if (Quote.isQuoted(arg)) return Quote.get(arg)
  return defaultQuote(arg)
}

const quote = (q, s) => new Quote(q, s)
const verbatim = (s) => quote('verbatim', s)
const expandable = (s) => quote('expandable', s)

usePwsh()

$.verbose = true

await $`Write-Host ${'verbatim string'}`

await $`Write-Host ${`verbatim
here-string`}`

await $`Write-Host ${expandable(
  `$($PSStyle.Foreground.Blue)expandable string$($PSStyle.Reset)`
)}`

await $`Write-Host ${expandable(
  `$($PSStyle.Foreground.Blue)expandable
here-string$($PSStyle.Reset)`
)}`

await $`Write-Host ${quote(
  (s) => s,
  `@"
Escaping and quoting mechanism is disabled here.
Which allows the user doing it by himself if needed.
"@`
)}`

[antonmedv]

What about instead of argument, use a different quote func?

usePwrSh()
£.quote = quoteExpandable

[pizzafroide]

Expandable strings replace PowerShell variables, such as $PSStyle.

[antonmedv]

Expandable strings replace PowerShell variables, such as $PSStyle.

Yes. Quotation mechanism should NOT do that. But escape all variables as strings.

[pizzafroide]

Ok but some PowerShell internal variables (such as $PSStyle) cannot be used except in an expandable string. That's what I mean by "giving the user more control over escaping and quoting". I was actually suggesting that quotation mechanism could do that if it is explicitly written in the code. In fact, the only way of using $PSStyle is, for now, to disable the quoting mechanism and quote the string by ourselves.

await $({ quote: s => s })`Write-Host "$($PSStyle.Foreground.Blue)${escapeExpandable(message)}$($PSStyle.Reset)"`

And I was suggesting that zx could export, or allow using, some other quotation mechanisms. Which would give, for example:

await $`Write-Host ${expand`$($PSStyle.Foreground.Blue)${message}$($PSStyle.Reset)`}`

[antonmedv]

Allowing this makes zx less strict and puts a security risk. For example, message can contain other $-Style variables which will be printed (and this is not wanted). Although Window usage in Google is low, it is still significant. We would not like to have insecure faults.

[pizzafroide]

I was thinking expand function would still escape its parameters though. But ok, fair enough! 😃