nvf/lib/lua.nix

# Helpers for converting values to lua
{lib}: let
  /**
  Test whether an object is a `luaInline` value (i.e. has `_type == "lua-inline"`).

  # Type

  ```
  isLuaInline :: Any -> Bool
  ```

  # Arguments

  - `object`: Any Nix value.

  # Example

  ```nix
  isLuaInline (lib.mkLuaInline "vim.fn.getcwd()")
  => true

  isLuaInline "just a string"
  => false
  ```
  */
  isLuaInline = object: (object._type or null) == "lua-inline";

  /**
  Recursively convert a Nix value to its Lua representation as a string.

  Handles all primitive Nix types as well as lists, attribute sets,
  derivations (rendered as their store path string), and `luaInline` values
  (rendered verbatim). Null attributes are stripped from sets.

  # Type

  ```
  toLuaObject :: Any -> String
  ```

  # Arguments

  - `args`: Any Nix value to convert.

  # Example

  ```nix
  toLuaObject { a = 1; b = true; c = null; }
  => ''{["a"] = 1,\n["b"] = true}''

  toLuaObject [ "x" "y" ]
  => ''{"x",\n"y"}''
  ```
  */
  toLuaObject = args:
    {
      int = toString args;
      float = toString args;

      # escapes \ and quotes
      string = builtins.toJSON args;
      path = builtins.toJSON args;

      bool = lib.boolToString args;
      null = "nil";

      list = "{${lib.concatMapStringsSep ",\n" toLuaObject args}}";

      set =
        if lib.isDerivation args
        then ''"${args}"''
        else if isLuaInline args
        then args.expr
        else "{${
          lib.pipe args [
            (lib.filterAttrs (_: v: v != null))
            (builtins.mapAttrs (
              n: v:
                if lib.hasPrefix "@" n
                then toLuaObject v
                else "[${toLuaObject n}] = ${toLuaObject v}"
            ))
            builtins.attrValues
            (lib.concatStringsSep ",\n")
          ]
        }}";
    }
    .${
      builtins.typeOf args
    }
    or (builtins.throw "Could not convert object of type `${builtins.typeOf args}` to lua object");
in
  {
    inherit isLuaInline toLuaObject;

    /**
    Convert a list of Lua expression strings into a Lua table string.

    Each element is wrapped with `mkLuaInline` before conversion so that
    strings are treated as raw Lua rather than quoted string literals.

    # Type

    ```
    luaTable :: [String] -> String
    ```

    # Arguments

    - `x`: List of Lua expression strings.

    # Example

    ```nix
    luaTable [ "vim.fn.getcwd()" "vim.fn.expand('%')" ]
    => ''{vim.fn.getcwd(),\nvim.fn.expand('%')}''
    ```
    */
    luaTable = x: (toLuaObject (map lib.mkLuaInline x));
  }
  // lib.genAttrs [
    "nullString"
    "expToLua"
    "listToLuaTable"
    "attrsetToLuaTable"
  ] (name: builtins.throw "${name} is deprecated use toLuaObject instead")