A restore node with dynamic default?

[bew]

Hello!

This is a snippet I wanted to do for the longest time but never managed to make it work like I want...

I want a snippet like lr that expands to local <var> = require"<module>"
When on <module>, if I type foo <var> should be foo, if I type foo.bar <var> should be bar.
If I move on <var> and type myvar it should remain myvar even if I move back to <module> and change it something.else..

I managed to get the first part of the behavior, with <var> being the last part of <module> by using a dynamic node for <var> and extracting the part I want from <module>.
But as soon as I try to get the second part of the behavior, with the ability to change <var> myself and have that retained it falls apart 🥲
I tried using a restore node in <var>'s dynamic node, but then it seems like I lose the dynamic part of updating <var>'s default when <module> changes..

Hence why what I'm looking for is a kind of restore node with a dynamic default, but I really don't know how to achieve that.

Am I going in the right direction?

---

For reference, snippet definition (using my own DSL helpers)

snip("lr", {desc = "local require"}, U.myfmt {
  [[local <var> = require"<module>"]],
  {
    module = i(1, "module", {key="mod-name"}),

    -- must be the 'last part of <module>' except if I set it to something else
    var = ls.dynamic_node(
      2,
      function(given_nodes_text)
        return ls.snippet_node(nil, { ls.restore_node(1, "var-name", i(nil, given_nodes_text[1])) })
      end,
      {node_ref"mod-name"}
    )
  },
})

[bew]

Friendly ping @L3MON4D3 since it seems you're reactive on other discussions but didn't reply here, maybe you missed it? 🤔

[L3MON4D3]

Oh thanks for the ping, I indeed did. Sorry about that 😅

[L3MON4D3]

Mhmmm, I think you'd need some custom logic there, or settle for something slightly simpler:

• custom logic: the restoreNode will not overwrite the stored insertNode => whenever mod-name is updated, the dynamicNode is called correctly, but the restoreNode will re-use the insertNode that was generated previously => there is no dynamic component.
  You could circumvent this by resetting the stored text when the dynamicNode is called (we don't have api for this, but you can do snippet.stored["var-name"] = nil for now), but then the text you enter yourself would also be lost upon every dynamicNode update.
  In any case, to get this to work exactly like you want, you'd have to track whether the text in <var> matches what you generated before (can do via snippet:get_keyed_node(<var>):get_text() and storing the generated text in dynamicNode-function).
• something simpler: replace <var> with a choiceNode which switches between your custom-name and the one generated from the module-name

Hope this helps :)

[bew]

For the record, I finally did an implementation that works and that I'm happy with 🚀
I went with a different solution using a choice node:

    var = ls.choice_node(2, {
      ls.function_node(
        function(given_nodes_text)
          local module_name = given_nodes_text[1][1]
          local last_part = vim.iter(vim.gsplit(module_name, ".", {plain=true})):last()
          return last_part
        end,
        {U.node_ref"mod-name"}
      ),
      i(nil, "mod"),
    })

Works perfectly, love your plugin ❤️ ❤️

edit: just now realized it was actually your second suggestion above ^^ welp, in the end it was the right call ¯\_(ツ)_/¯

[L3MON4D3]

Oh yeah, that looks good, very KISS :D
Thank you for the kind words🫶 :)

[bew]

Hello again o/

I tried an alternative implementation using choice node at the root and sharing the module path, but for some reason when I switch the 2nd branch of the choice node, the <modpath> node's text is lost..

(using my DSL, but should be mostly straightforward to migrate)

snip("lr", {desc = [[local require"…"]], when = conds.start_of_line}, ls.choice_node(1, {
  ls.snippet_node(nil, SU.myfmt {
    [[local <name> = require"<modpath>"]],
    {
      modpath = ls.restore_node(1, "modpath"),
      name = i(2, "name"),
    }
  }),
  ls.snippet_node(nil, SU.myfmt {
    [[local <autoname> = require"<modpath>"]],
    {
      modpath = ls.restore_node(1, "modpath", nil, {key="mod-path"}),
      autoname = ls.function_node(
        function(given_nodes_text)
          local module_name = given_nodes_text[1][1]
          local last_part = vim.iter(vim.gsplit(module_name, ".", {plain=true})):last()
          return last_part
        end,
        {SU.node_ref"mod-path"}
      ),
    }
  }),
}), {
  stored = {
    -- Keys for ls.restore_node
    -- (used to share nodes between choice node branches ✨)
    modpath = i(nil, "the.module"),
  },
})

But I did something very similar for another snippet that works correctly..
👉 Any idea what I might be missing?

Also, question: what is the nodes param for restore_node ? (I tried to pass nil but there's no explanation for it..)

[L3MON4D3]

Hi :)

Oh, I think that might be a bug on the current master, could you try the self-dependent-dNode-branch? It overhauls quite a lot, but should mostly work and has a few fixes surrounding restoreNode and restoring node-content in general

The nodes-param is just the default-content, it can be given "inline" instead of passed to the snippet via stored

[bew]

Hi, I just tested my snippet above on your branch and I'm still seeing the same issue 🤔