vscode-liquidsoap 0.2.0 → 0.3.1

package/package.json

@@ -5,9 +5,9 @@
   "publisher": "savonet",
   "repository": "https://github.com/savonet/vscode-liquidsoap.git",
   "homepage": "https://github.com/savonet/vscode-liquidsoap",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "engines": {
-    "vscode": "^1.82.0"
+    "vscode": "^1.98.0"
   },
   "icon": "assets/logo.png",
   "license": "MIT",
@@ -16,6 +16,15 @@
     "Formatters"
   ],
   "main": "dist/extension.js",
+  "scripts": {
+    "release": "pnpm build && vsce publish",
+    "build": "webpack --config webpack.config.js",
+    "typecheck": "tsc --noEmit",
+    "update:snapshots": "vscode-tmgrammar-snap --updateSnapshot tests/snap/**/*.liq",
+    "test:fetch-stdlib": "node test-suite/fetch-stdlib.js",
+    "test": "node test-suite/run-tests.js",
+    "test:full": "npm run test:fetch-stdlib && npm run test"
+  },
   "contributes": {
     "languages": [
       {
@@ -45,14 +54,10 @@
     "prettier": "^3.5.3",
     "ts-loader": "^9.5.2",
     "typescript": "^5.8.2",
+    "vscode-oniguruma": "^1.7.0",
+    "vscode-textmate": "^9.0.0",
     "vscode-tmgrammar-test": "^0.1.3",
     "webpack": "^5.98.0",
     "webpack-cli": "^5.1.4"
-  },
-  "scripts": {
-    "release": "pnpm build && vsce publish",
-    "build": "webpack --config webpack.config.js",
-    "typecheck": "tsc --noEmit",
-    "update:snapshots": "vscode-tmgrammar-snap --updateSnapshot tests/snap/**/*.liq"
   }
-}
+}

package/syntaxes/liquidsoap.sublime-syntax

@@ -370,6 +370,11 @@ contexts:
           pop: true
         - match: \\/
           scope: constant.character.escape.liquidsoap
+    - match: '\{([a-z_]*)\|'
+      push:
+        - meta_scope: string.unquoted.raw.liquidsoap
+        - match: '\|\1\}'
+          pop: true
   types:
     - match: \b(int|float|unit|bool)(?:(\?)|\b)
       captures:

package/syntaxes/liquidsoap.tmLanguage

@@ -1109,6 +1109,14 @@
             <key>name</key>
             <string>string.regexp.liquidsoap</string>
           </dict>
+          <dict>
+            <key>name</key>
+            <string>string.unquoted.raw.liquidsoap</string>
+            <key>begin</key>
+            <string>\{([a-z_]*)\|</string>
+            <key>end</key>
+            <string>\|\1\}</string>
+          </dict>
         </array>
       </dict>
       <key>string-escapes</key>

package/syntaxes/liquidsoap.tmLanguage.json

@@ -13,7 +13,11 @@
       "patterns": [
         {
           "name": "keyword.other.liquidsoap",
-          "match": "(%ifdef|%ifndef|%ifversion|%ifnversion|%ifencoder|%ifnencoder|%else|%endif)\\b"
+          "match": "(%ifdef|%ifndef|%ifversion|%ifnversion|%ifencoder|%ifnencoder|%else|%endif|%include_extra|%include)\\b"
+        },
+        {
+          "name": "keyword.other.liquidsoap",
+          "match": "\\bopen\\b"
         },
         {
           "name": "keyword.control.function.declaration.liquidsoap",
@@ -23,6 +27,10 @@
           "name": "keyword.operator.boolean.liquidsoap",
           "match": "\\b(and|or|not)\\b"
         },
+        {
+          "name": "keyword.operator.arithmetic.liquidsoap",
+          "match": "\\bmod\\b"
+        },
         {
           "name": "keyword.operator.spread.liquidsoap",
           "match": "\\.\\.\\."
@@ -35,6 +43,10 @@
           "name": "keyword.operator.arithmetic.liquidsoap",
           "match": "[+\\-/*]\\.?"
         },
+        {
+          "name": "keyword.operator.concat.liquidsoap",
+          "match": "\\^"
+        },
         {
           "name": "keyword.operator.compare.liquidsoap",
           "match": "(>=|<=|>|<|==|!=)"
@@ -47,6 +59,10 @@
           "name": "keyword.operator.coalesce.liquidsoap",
           "match": "\\?\\?"
         },
+        {
+          "name": "keyword.operator.dereference.liquidsoap",
+          "match": "!(?=[a-zA-Z_])"
+        },
         {
           "comment": "comma separator",
           "name": "keyword.other.liquidsoap punctuation.comma punctuation.separator.comma",
@@ -214,6 +230,10 @@
               },
               "patterns": [{ "include": "#expressions" }]
             },
+            {
+              "match": "\\bfinally\\b",
+              "name": "keyword.control.liquidsoap"
+            },
             { "include": "$self" }
           ]
         },
@@ -276,7 +296,7 @@
     "types": {
       "patterns": [
         {
-          "match": "\\b(int|float|unit|bool)(?:(\\?)|\\b)",
+          "match": "\\b(int|float|unit|bool|string|never|ref)(?:(\\?)|\\b)",
           "captures": {
             "1": { "name": "storage.type.ground.liquidsoap" },
             "2": { "name": "keyword.other.liquidsoap" }
@@ -410,11 +430,11 @@
           "name": "constant.numeric.decimal.float.liquidsoap"
         },
         {
-          "match": "\\b0(x|X)[0-9][0-9a-fA-F_]+\\b",
+          "match": "\\b0(x|X)[0-9a-fA-F][0-9a-fA-F_]*\\b",
           "name": "constant.numeric.hexadecimal.integer.liquidsoap"
         },
         {
-          "match": "\\b0(o|O)[0-9][0-9_]+\\b",
+          "match": "\\b0(o|O)[0-7][0-7_]*\\b",
           "name": "constant.numeric.octal.integer.liquidsoap"
         },
         {
@@ -472,6 +492,14 @@
         {
           "match": "@argsof",
           "name": "comment.doc.argsof.liquidsoap"
+        },
+        {
+          "match": "@flag",
+          "name": "comment.doc.flag.liquidsoap"
+        },
+        {
+          "match": "@docof",
+          "name": "comment.doc.docof.liquidsoap"
         }
       ]
     },
@@ -499,6 +527,11 @@
             }
           ],
           "name": "string.regexp.liquidsoap"
+        },
+        {
+          "name": "string.unquoted.raw.liquidsoap",
+          "begin": "\\{([a-z_]*)\\|",
+          "end": "\\|\\1\\}"
         }
       ]
     },
@@ -509,16 +542,17 @@
           "match": "\\\\."
         },
         {
-          "name": "string.interpolation.liquidsoap",
+          "name": "meta.interpolation.liquidsoap",
+          "contentName": "meta.embedded.line.liquidsoap",
           "begin": "#\\{",
           "end": "\\}",
-          "patterns": [
-            {
-              "name": "string.interpolation.escape.liquidsoap",
-              "match": "\\\\}"
-            },
-            { "include": "#expressions" }
-          ]
+          "beginCaptures": {
+            "0": { "name": "punctuation.section.interpolation.begin.liquidsoap" }
+          },
+          "endCaptures": {
+            "0": { "name": "punctuation.section.interpolation.end.liquidsoap" }
+          },
+          "patterns": [{ "include": "#expressions" }]
         }
       ]
     },

package/test-suite/fetch-stdlib.js

@@ -0,0 +1,125 @@
+#!/usr/bin/env node
+
+/**
+ * Fetches liquidsoap standard library files from GitHub for testing
+ */
+
+const https = require("https");
+const fs = require("fs");
+const path = require("path");
+
+const GITHUB_API = "https://api.github.com";
+const REPO_OWNER = "savonet";
+const REPO_NAME = "liquidsoap";
+const LIBS_PATH = "src/libs";
+const OUTPUT_DIR = path.join(__dirname, "stdlib");
+
+async function fetchJson(url) {
+  return new Promise((resolve, reject) => {
+    const options = {
+      headers: {
+        "User-Agent": "vscode-liquidsoap-test-suite",
+        Accept: "application/vnd.github.v3+json",
+      },
+    };
+
+    https
+      .get(url, options, (res) => {
+        let data = "";
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => {
+          if (res.statusCode === 200) {
+            resolve(JSON.parse(data));
+          } else {
+            reject(
+              new Error(`HTTP ${res.statusCode}: ${data.substring(0, 200)}`)
+            );
+          }
+        });
+      })
+      .on("error", reject);
+  });
+}
+
+async function fetchRaw(url) {
+  return new Promise((resolve, reject) => {
+    https
+      .get(url, { headers: { "User-Agent": "vscode-liquidsoap-test-suite" } }, (res) => {
+        if (res.statusCode === 301 || res.statusCode === 302) {
+          fetchRaw(res.headers.location).then(resolve).catch(reject);
+          return;
+        }
+        let data = "";
+        res.on("data", (chunk) => (data += chunk));
+        res.on("end", () => {
+          if (res.statusCode === 200) {
+            resolve(data);
+          } else {
+            reject(new Error(`HTTP ${res.statusCode}`));
+          }
+        });
+      })
+      .on("error", reject);
+  });
+}
+
+async function getDirectoryContents(dirPath) {
+  const url = `${GITHUB_API}/repos/${REPO_OWNER}/${REPO_NAME}/contents/${dirPath}`;
+  return fetchJson(url);
+}
+
+async function downloadFile(file, outputPath) {
+  console.log(`  Downloading: ${file.name}`);
+  const content = await fetchRaw(file.download_url);
+  fs.writeFileSync(outputPath, content, "utf8");
+}
+
+async function processDirectory(dirPath, outputDir) {
+  const contents = await getDirectoryContents(dirPath);
+
+  for (const item of contents) {
+    const itemOutputPath = path.join(outputDir, item.name);
+
+    if (item.type === "dir") {
+      fs.mkdirSync(itemOutputPath, { recursive: true });
+      await processDirectory(item.path, itemOutputPath);
+    } else if (item.name.endsWith(".liq")) {
+      await downloadFile(item, itemOutputPath);
+    }
+  }
+}
+
+async function main() {
+  console.log("Fetching liquidsoap standard library files...\n");
+
+  // Clean and create output directory
+  if (fs.existsSync(OUTPUT_DIR)) {
+    fs.rmSync(OUTPUT_DIR, { recursive: true });
+  }
+  fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+
+  try {
+    await processDirectory(LIBS_PATH, OUTPUT_DIR);
+    console.log("\nDone! Files saved to:", OUTPUT_DIR);
+
+    // Count files
+    const countFiles = (dir) => {
+      let count = 0;
+      for (const item of fs.readdirSync(dir)) {
+        const fullPath = path.join(dir, item);
+        if (fs.statSync(fullPath).isDirectory()) {
+          count += countFiles(fullPath);
+        } else if (item.endsWith(".liq")) {
+          count++;
+        }
+      }
+      return count;
+    };
+    console.log(`Total .liq files: ${countFiles(OUTPUT_DIR)}`);
+  } catch (err) {
+    console.error("Error:", err.message);
+    process.exit(1);
+  }
+}
+
+main();