Template String Support?

[jaidetree]

Is your feature request related to a problem? Please describe.
Trying to use https://github.com/google/zx with nbb again but its api has appeared to change since I've last worked with those two packages.

Describe the solution you'd like
A clear and concise description of what you want to happen.

Thinking a similar js-template-str macro that partitions its list of args into strings and symbols. The list of strings is applied as the first arg to the tagged template fn and the symbols are passed in as args via apply.

(def some-var "./nbb.edn")

(js-template-str "git add " some-var)
;; # => I think
;; [#js ["git add"] "./nbb.edn"]

;; Could be used with zx$ like
(apply zx$ (js-template-str "cat" some-var))

Describe alternatives you've considered

• Babashka could probably work in most cases, but I am working with the jimp node image library
• My use case is just simple enough where a lightweight wrapper around cp.exec could work, but at the same time zx + nbb would be cool to have in our community toolbelt

Additional context

• Other packages I've used, especially around sql libraries, leverage tagged template literals so supporting officially somehow would be worth it.

[borkdude]

I have read the post, but I don't understand some parts.

(js-template-str "git add " some-var)

Isn't js-template-str just the str function here?

What about using goog.string.format which is available in nbb?

[jaidetree]

goog.string.format works for problems where I'm just trying to format a string. But in the case of libraries like zx, goog string format would not work. Same with using the sql function from packages like slonik.

In js land:

import $ from 'zx'

$`ls -a ${path.join(process.cwd(), 'nbb.edn')}` 

Will call the $ function like:

$(['ls -a '], '/Users/j/projects/cljs-piano/nbb.edn')

Where each str is included in that first array of strings, then each interpolation value is provided as a function arg.

https://github.com/google/zx/blob/4999435182fe1f34f6b2ef2471184d9878456b5e/src/core.ts#L93

So that macro could be used like this:

(require '['zx' :refer [$]]
         '['path' :as path])

(apply $ (js-template-str "ls -a" (.join path (js/process.cwd) "nbb.edn")))

Took a stab at a first draft:

(defmacro js-template-str
  [& args]
  (let [[strs# args#] (partition-by string? args)
        result# (cons (clj->js (conj (vec strs#) "")) args#)]
    `(list ~@result#)))

(comment
  (macroexpand-1
    '(js-template-str "iconutil -c icns " (.join path (js/process.cwd) "nbb.edn"))))

;; => (#js ["iconutil -c icns "] (.join path (js/process.cwd) "nbb.edn"))

[borkdude]

I've had a discussion about template string support here:

squint-cljs/squint#40

There was also a string interpolation << macro in incubator:

https://clojure.github.io/clojure-contrib/strint-api.html

The output of your macro seems pretty specific to what zx expects or are there more general use cases?

[jaidetree]

With that macro in cljs:

(apply anyTemplateTag (js-template-str "str-a str-b and " (str "dynamic data")))

Without that macro in cljs:

(anyTemplateTag #js ["str-a str-b and " ""] (str "dynamic data"))

If let's say we wanted to use str-a str-b ${"dynamic-data"} and str-c:

(anyTemplateTag #js ["str-a str-b " " and str-c" ""] (str "dynamic-data"))

So working with template str functions are really unintuitive because you have to separate the list of plain strings from the data args that would be interspersed between each string chunk.

[jaidetree]

The use case for template strings in js land is so that they template tag functions can process args separately from static template content. In slonik's sql template tag function, it's used to escape raw data values to prevent sql injection. The order would be reconstructed in the final output with something like:

function anyTemplateTag(strings, ...args) {
  let outputStr = ''
  for (let i = 0; i <= strings.length; i++) {
    outputStr += strings[0] + (i <= args.length ? processRawValue(args[i]) : "")
  }

  return outputstr
}

That's probably not perfect but is a close approximation. I've never written a template tag function myself, but I've used a few from libraries like zx, sql with slonik, and graphql queries

[borkdude]

Ah right, so you can re-construct by interleaving the strings and args.

[jaidetree]

You got it! Thinking about it, maybe the js-template-str macro doesn't really need to work on its own. It would only be useful when working with some js library's template tag function, otherwise you would just use goog.string.format or the str function.

Alternative interfaces and names:

(<< zx "str-a str-b " (str "dynamic-data") " and str-c")

(<< (zx "str-a str-b " (str "dynamic-data") " and str-c"))

(js-template-tag (zx "str-a str-b " (str "dynamic-data") " and str-c"))

(jstag (zx "str-a str-b " (str "dynamic-data") " and str-c"))

I don't have any strong preference about the interface and name on this one. Open to other ideas too if any come to mind.

[borkdude]

I'll play around with some ideas and will post them here if I have anything.