nur-packages/bin/update-jetbrains-plugins.py

193 lines
5.2 KiB
Python
Executable File

#! /usr/bin/env nix-shell
#! nix-shell -i python3 -p python3Packages.lxml python3Packages.requests
import argparse
import re
import requests
import subprocess as sp
import sys
import urllib
from lxml import etree
# https://plugins.jetbrains.com/docs/marketplace/product-codes.html
PRODUCT_CODE = {
"clion": "CL",
"datagrip": "DB",
"goland": "GO",
"idea-community": "IC",
"idea-ultimate": "IU",
"phpstorm": "PS",
"pycharm-community": "PC",
"pycharm-professional": "PY",
"rider": "RD",
"ruby-mine": "RM",
"webstorm": "WS",
}
def to_slug(name):
slug = name.replace(" ", "-").lstrip(".")
for char in ",/;'\\<>:\"|!@#$%^&*()":
slug = slug.replace(char, "")
return slug
class Build:
"""
Transforms a Nixpkgs derivation name into a Jetbrains product code. For
example:
idea-community-2019.3.2 -> IC-193.2
"""
def __init__(self, name):
m = re.search("([0-9]+\.?)+$", name)
version = m.group(0)
code = PRODUCT_CODE[name.replace("-" + version, "")]
vparts = version.split(".")
version = vparts[0][-2:] + vparts[1] + "." + vparts[2]
self.code = code
self.version = version
self.package = name.split("-")[0]
def builder(self):
return self.package + "Build"
def __repr__(self):
return self.code + "-" + self.version
class Plugin:
def __init__(self, data, category=None):
self.category = category
self.name = data.find("name").text
self.id = data.find("id").text
self.description = data.find("description").text
self.url = data.get("url") or data.find("vendor").get("url")
self.version = data.find("version").text
self.slug = to_slug(self.name)
self.depends = []
for depend in data.findall("depends"):
self.depends.append(depend.text)
def __repr__(self):
return f"<Plugin '{self.name}' {self.version}>"
def download_url(self, build, follow_redirect=False):
id = urllib.parse.quote(self.id)
return f"https://plugins.jetbrains.com/pluginManager?action=download&id={id}&build={build}"
def packagename(self):
slug = self.slug.lower().replace(".", "-")
if slug[0] in "1234567890":
return "_" + slug
else:
return slug
def filename(self):
return f"{self.slug}-{self.version}.jar"
def list_plugins(build):
"""
Lists all plugins for the specified build code.
https://plugins.jetbrains.com/docs/marketplace/plugins-list.html
"""
resp = requests.get(f"https://plugins.jetbrains.com/plugins/list/?build={build}")
return parse_repository(resp.content)
def parse_repository(content):
tree = etree.XML(content)
plugins = []
for cat in tree.findall("category"):
cat_name = cat.get("name")
for plugin in cat.findall("idea-plugin"):
plugins.append(Plugin(plugin, cat_name))
return plugins
def prefetch(plugin, build):
res = sp.run(
["nix-prefetch-url", "--name", plugin.filename(), plugin.download_url(build)],
capture_output=True,
)
if not res.stdout:
raise IOError(f"nix-prefetch-url {plugin} failed: {res.stderr.decode('utf-8')}")
return res.stdout.decode("utf-8").strip()
def write_packages(outfile, plugins, build):
builder = build.builder()
outfile.write("{callPackage}:\n{")
for plugin in plugins:
try:
sha = prefetch(plugin, build)
except IOError as e:
print(e, file=sys.stderr)
continue
# TODO: Dependencies are provided as package IDs but refer to both
# internal and external plugins; need to find some way to resolve them
requires = []
# TODO: Licenses are actually on the website, but aren't provided in the API
license = "lib.license.free"
outfile.write(
f"""
{plugin.packagename()} = callPackage ({{ {builder}, fetchurl, lib }}): {builder} {{
pname = "{plugin.slug}";
plugname = "{plugin.name}";
plugid = "{plugin.id}";
version = "{plugin.version}";
src = fetchurl {{
url = "{plugin.download_url(build)}";
sha256 = "{sha}";
name = "{plugin.filename()}";
}};
packageRequires = {requires};
meta = {{
{f'homepage = {plugin.url};' if plugin.url else ''}
license = {license};
}};
}}) {{}};
"""
)
outfile.write("}\n")
def main():
parser = argparse.ArgumentParser()
parser.add_argument(
"-n", "--number", type=int, help="Limit the number of packages to write",
)
parser.add_argument(
"-o", "--out", type=str, help="File to write plugins to",
)
parser.add_argument(
"package",
metavar="PACKAGE",
type=str,
help="The Nixpkgs package name (inc. version)",
)
args = parser.parse_args()
build = Build(args.package)
plugins = list_plugins(build)
plugins.sort(key=lambda p: p.slug)
if args.number:
plugins = plugins[: args.number]
if not args.out:
write_packages(sys.stdout, plugins, build)
else:
with open(args.out, "w") as f:
write_packages(f, plugins, build)
main()