feat: support zls installation (#23)

Author: jiacai2050

.github/workflows/build.yml

@@ -11,7 +11,7 @@ jobs:
   script-test:
     env:
       ASDF_DOWNLOAD_PATH: /tmp/asdf-download
-      ASDF_INSTALL_VERSION: 0.14.1
+      ASDF_INSTALL_VERSION: 0.15.1
       ASDF_INSTALL_TYPE: version
       ASDF_INSTALL_PATH: /tmp/asdf-install
     strategy:
@@ -22,6 +22,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v5
+      - uses: astral-sh/ruff-action@v3
       - run: |
           bin/download
       - run: |

.ruff.toml

@@ -0,0 +1,2 @@
+[format]
+quote-style = "single"

README.md

@@ -4,6 +4,9 @@
 
 [Zig](http://ziglang.org/) plugin for the [asdf version manager](https://asdf-vm.com).
 
+As a bonus, this plugin supports installing zls as well, so zls and zig version can match exactly.
+
+
 </div>
 
 # Dependencies
@@ -31,8 +34,11 @@ asdf install zig latest
 # Set a version globally (on your ~/.tool-versions file)
 asdf set --home zig latest
 
-# Now asdf-zig commands are available
+# Now zig commands are available
 zig version
+
+# Also you can check zls match zig version
+zls version
 ```
 
 Check [asdf](https://github.com/asdf-vm/asdf) readme for more instructions on how to

bin/download

@@ -7,12 +7,17 @@ SCRIPT_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" &>/dev/null && pwd -P)
 download() {
   local download_path="$1"
   local version="$2"
-  local release_file="${download_path}/${version}.tar.xz"
+  local zig_outfile="${download_path}/zig-${version}.tar.xz"
+  local zls_outfile="${download_path}/zls-${version}.tar.xz"
   mkdir -p "$download_path"
 
-  "${SCRIPT_DIR}/../lib/utils.py" download "${version}" "${release_file}"
-  tar -xf "$release_file" -C "$download_path" --strip-components=1
-  rm "$release_file"
+  "${SCRIPT_DIR}/../lib/utils.py" download "${version}" "${zig_outfile}" "${zls_outfile}"
+  tar -xf "$zig_outfile" -C "$download_path" --strip-components=1
+  if [ -f "$zls_outfile" ]; then
+    tar -xf "$zls_outfile" -C "$download_path"
+    rm "$zls_outfile"
+  fi
+  rm "$zig_outfile"
 }
 
 download "$ASDF_DOWNLOAD_PATH" "$ASDF_INSTALL_VERSION"

bin/install

@@ -16,6 +16,9 @@ install_version() {
         cp -r "$ASDF_DOWNLOAD_PATH"/* "$install_path"
         mkdir -p "$install_path/bin"
         mv "$install_path/zig" "$install_path/bin/zig"
+        if test -x "$install_path/zls"; then
+          mv "$install_path/zls" "$install_path/bin/zls"
+        fi
 
         local tool_cmd="zig"
         if ! test -x "$install_path/bin/$tool_cmd"; then
@@ -24,6 +27,9 @@ install_version() {
         fi
 
         echo "zig $version installation was successful!"
+        if test -x "$install_path/bin/zls"; then
+          echo "zls $version also get installed!"
+        fi
     ) || (
         rm -rf "$install_path"
         fail "An error occurred while installing $TOOL_NAME $version."

lib/utils.py

@@ -12,69 +12,85 @@
 import hashlib
 import logging
 
-INDEX_URL = os.getenv("ASDF_ZIG_INDEX_URL", "https://ziglang.org/download/index.json")
-HTTP_TIMEOUT = int(os.getenv("ASDF_ZIG_HTTP_TIMEOUT", "30"))
-USER_AGENT = "asdf-zig (https://github.com/asdf-community/asdf-zig)"
+INDEX_URL = os.getenv('ASDF_ZIG_INDEX_URL', 'https://ziglang.org/download/index.json')
+HTTP_TIMEOUT = int(os.getenv('ASDF_ZIG_HTTP_TIMEOUT', '30'))
+USER_AGENT = 'asdf-zig (https://github.com/asdf-community/asdf-zig)'
 
 # https://github.com/mlugg/setup-zig/blob/main/mirrors.json
 # If any of these mirrors are down, please open an issue!
 MIRRORS = [
-    "https://pkg.machengine.org/zig",
-    "https://zigmirror.hryx.net/zig",
-    "https://zig.linus.dev/zig",
-    "https://fs.liujiacai.net/zigbuilds",
+    'https://pkg.machengine.org/zig',
+    'https://zigmirror.hryx.net/zig',
+    'https://zig.linus.dev/zig',
+    'https://fs.liujiacai.net/zigbuilds',
 ]
 OS_MAPPING = {
-    "darwin": "macos",
+    'darwin': 'macos',
 }
 ARCH_MAPPING = {
-    "i386": "x86",
-    "i686": "x86",
-    "amd64": "x86_64",
-    "arm64": "aarch64",
+    'i386': 'x86',
+    'i686': 'x86',
+    'amd64': 'x86_64',
+    'arm64': 'aarch64',
 }
 
+
 class HTTPAccessError(Exception):
     def __init__(self, url, code, reason, body):
-        super().__init__(f"{url} access failed, code:{code}, reason:{reason}, body:{body}")
+        super().__init__(
+            f'{url} access failed, code:{code}, reason:{reason}, body:{body}'
+        )
         self.url = url
         self.code = code
         self.reason = reason
         self.body = body
 
+
 def http_get(url, timeout=HTTP_TIMEOUT):
     try:
         req = urllib.request.Request(url, headers={'User-Agent': USER_AGENT})
         return urllib.request.urlopen(req, timeout=timeout)
     except HTTPError as e:
-        body = e.read().decode("utf-8")
+        body = e.read().decode('utf-8')
         raise HTTPAccessError(url, e.code, e.reason, body)
 
+
 def fetch_index():
     with http_get(INDEX_URL) as response:
-        body = response.read().decode("utf-8")
+        body = response.read().decode('utf-8')
+        return json.loads(body)
+
+
+def query_zls(zig_version):
+    url = f'https://releases.zigtools.org/v1/zls/select-version?zig_version={zig_version}&compatibility=full'
+    with http_get(url) as response:
+        body = response.read().decode('utf-8')
         return json.loads(body)
 
 
 def all_versions():
     index = fetch_index()
-    versions = [k for k in index.keys() if k != "master"]
-    versions.sort(key=lambda v: tuple(map(int, v.split("."))))
+    versions = [k for k in index.keys() if k != 'master']
+    versions.sort(key=lambda v: tuple(map(int, v.split('.'))))
     return versions
 
 
 def download_and_check(url, out_file, expected_shasum, total_size):
-    logging.info(f"Begin download tarball({total_size}) from {url} to {out_file}...")
-    chunk_size = 1024 * 1024 # 1M chunks
+    logging.info(f'Begin download tarball({total_size}) from {url} to {out_file}...')
+    chunk_size = 1024 * 1024  # 1M chunks
     sha256_hash = hashlib.sha256()
     with http_get(url) as response:
         read_size = 0
-        with open(out_file, "wb") as f:
+        with open(out_file, 'wb') as f:
             while True:
                 chunk = response.read(chunk_size)
                 read_size += len(chunk)
-                progress_percentage = (read_size / total_size) * 100 if total_size > 0 else 0
-                logging.info(f'Downloaded: {read_size}/{total_size} bytes ({progress_percentage:.2f}%)')
+                progress_percentage = (
+                    (read_size / total_size) * 100 if total_size > 0 else 0
+                )
+                logging.info(
+                    f'Downloaded: {read_size}/{total_size} bytes ({progress_percentage:.2f}%)'
+                )
                 if not chunk:
                     break  # eof
                 sha256_hash.update(chunk)
@@ -83,62 +99,77 @@ def download_and_check(url, out_file, expected_shasum, total_size):
     actual = sha256_hash.hexdigest()
     if actual != expected_shasum:
         raise Exception(
-            f"Shasum not match, expected:{expected_shasum}, actual:{actual}"
+            f'Shasum not match, expected:{expected_shasum}, actual:{actual}'
         )
 
 
-def download_tarball(url, out_file, expected_shasum, total_size):
-    filename = url.split("/")[-1]
+def download_tarball(out_file, tarball_info, use_mirror=True):
+    url = tarball_info['tarball']
+    expected_shasum = tarball_info['shasum']
+    total_size = int(tarball_info['size'])
+
+    if use_mirror is False:
+        download_and_check(url, out_file, expected_shasum, total_size)
+        return
+
+    filename = url.split('/')[-1]
     random.shuffle(MIRRORS)
 
     for mirror in MIRRORS:
         try:
             # Ensure base_url has a trailing slash
             mirror = mirror if mirror.endswith('/') else mirror + '/'
-            download_and_check(urljoin(mirror, filename), out_file, expected_shasum, total_size)
+            download_and_check(
+                urljoin(mirror, filename), out_file, expected_shasum, total_size
+            )
             return
         except Exception as e:
-            logging.error(f"Current mirror failed, try next. err:{e}")
+            logging.error(f'Current mirror failed, try next. err:{e}')
 
     # All mirrors failed, fallback to original url
     download_and_check(url, out_file, expected_shasum, total_size)
 
 
-def download(version, out_file):
+def download(version, zig_outfile, zls_outfile):
     index = fetch_index()
     if version not in index:
-        raise Exception(f"There is no such version: {version}")
+        raise Exception(f'There is no such version: {version}')
 
     links = index[version]
     os_name = platform.system().lower()
     arch = platform.machine().lower()
     os_name = OS_MAPPING.get(os_name, os_name)
     arch = ARCH_MAPPING.get(arch, arch)
-    link_key = f"{arch}-{os_name}"
+    link_key = f'{arch}-{os_name}'
     if link_key not in links:
-        raise Exception(f"No tarball link for {link_key} in {version}")
+        raise Exception(f'No tarball link for {link_key} in {version}')
+
+    tarball_info = links[link_key]
+    download_tarball(zig_outfile, tarball_info)
+
+    zls_links = query_zls(version)
+    if link_key not in zls_links:
+        return
 
-    tarball_url = links[link_key]["tarball"]
-    tarball_shasum = links[link_key]["shasum"]
-    tarball_size = int(links[link_key]["size"])
-    download_tarball(tarball_url, out_file, tarball_shasum, tarball_size)
+    tarball_info = zls_links[link_key]
+    download_tarball(zls_outfile, tarball_info, use_mirror=False)
 
 
 def main(args):
-    command = args[0] if args else "all-versions"
-    if command == "all-versions":
+    command = args[0] if args else 'all-versions'
+    if command == 'all-versions':
         versions = all_versions()
-        print(" ".join(versions))
-    elif command == "latest-version":
+        print(' '.join(versions))
+    elif command == 'latest-version':
         versions = all_versions()
         print(versions[-1])
-    elif command == "download":
-        download(args[1], args[2])
+    elif command == 'download':
+        download(args[1], args[2], args[3])
     else:
-        logging.error(f"Unknown command: {command}")
+        logging.error(f'Unknown command: {command}')
         sys.exit(1)
 
 
-if __name__ == "__main__":
+if __name__ == '__main__':
     logging.basicConfig(level=logging.INFO, format='[%(asctime)s] %(message)s')
     main(sys.argv[1:])