omdev 0.0.0.dev525__tar.gz → 0.0.0.dev526__tar.gz

{omdev-0.0.0.dev525/omdev.egg-info → omdev-0.0.0.dev526}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omdev
-Version: 0.0.0.dev525
+Version: 0.0.0.dev526
 Summary: omdev
 Author: wrmsr
 License-Expression: BSD-3-Clause
@@ -14,7 +14,7 @@ Classifier: Programming Language :: Python :: 3.13
 Requires-Python: >=3.13
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: omlish==0.0.0.dev525
+Requires-Dist: omlish==0.0.0.dev526
 Provides-Extra: all
 Requires-Dist: black~=26.1; extra == "all"
 Requires-Dist: pycparser~=3.0; extra == "all"

{omdev-0.0.0.dev525 → omdev-0.0.0.dev526}/omdev/.omlish-manifests.json

@@ -110,6 +110,18 @@
       }
     }
   },
+  {
+    "module": ".java.__main__",
+    "attr": "_CLI_MODULE",
+    "file": "omdev/java/__main__.py",
+    "line": 4,
+    "value": {
+      "!.cli.types.CliModule": {
+        "name": "java",
+        "module": "omdev.java.__main__"
+      }
+    }
+  },
   {
     "module": ".magic.__main__",
     "attr": "_CLI_MODULE",

{omdev-0.0.0.dev525 → omdev-0.0.0.dev526}/omdev/dockerdev/resources/depsets/system.toml

@@ -38,6 +38,7 @@ deps = [
   'pkg-config',
 
   # language toolchains & runtimes
+  'maven',
   'nodejs',
   'npm',
   'perl',

omdev-0.0.0.dev526/omdev/java/__main__.py

@@ -0,0 +1,11 @@
+from ..cli import CliModule
+
+
+# @omlish-manifest
+_CLI_MODULE = CliModule('java', __name__)
+
+
+if __name__ == '__main__':
+    from .cli import _main  # noqa
+
+    _main()

omdev-0.0.0.dev526/omdev/java/cli.py

@@ -0,0 +1,238 @@
+"""
+TODO:
+ - JAVA_HOME
+
+See:
+ - https://github.com/jbangdev/jbang
+ - https://docs.oracle.com/en/java/javase/17/docs/specs/man/java.html#using-source-file-mode-to-launch-single-file-source-code-programs
+"""  # noqa
+import os.path
+import re
+import shutil
+import subprocess
+import tempfile
+import typing as ta
+
+from omlish import check
+from omlish.argparse import all as ap
+
+from .. import intellij as ij
+from .. import magic
+from . import pomgen as pg
+
+
+##
+
+
+PACKAGE_PAT = re.compile(r'package\s+(\S+);\s*')
+
+DEFAULT_PROJECT_GROUP_ID = 'tmp'
+DEFAULT_PROJECT_VERSION = '0.0.1-SNAPSHOT'
+
+DEFAULT_JAVA_VERSION = '17'
+
+
+def scan_jdeps(src: str) -> ta.Sequence[str]:
+    src_magics = magic.find_magic(  # noqa
+        magic.C_MAGIC_STYLE,
+        src.splitlines(),
+        preparer=magic.json_magic_preparer,
+    )
+
+    deps: list[str] = []
+
+    for src_magic in src_magics:
+        if src_magic.key == '@omlish-jdeps':
+            for dep in check.isinstance(src_magic.prepared, ta.Sequence):  # noqa
+                deps.append(dep)  # noqa
+
+    return deps
+
+
+def build_maven_project(
+        root_dir: str,
+        src_file: str,
+        *,
+        deps: ta.Sequence[str] | None = None,
+) -> pg.Project:
+    with open(src_file) as f:
+        src = f.read()
+
+    #
+
+    name = os.path.basename(src_file).split('.', maxsplit=1)[0]
+
+    if (pms := list(filter(None, map(PACKAGE_PAT.fullmatch, src.splitlines())))):
+        group_id = pms[0].group(1)
+    else:
+        group_id = DEFAULT_PROJECT_GROUP_ID
+        src = f'package {group_id};\n\n{src}'
+
+    check.non_empty_str(group_id)
+    group_id_parts = group_id.split('.')
+    for gi_part in group_id_parts:
+        check.non_empty_str(gi_part)
+        check.arg(gi_part.isalnum())
+
+    #
+
+    if deps is None:
+        deps = scan_jdeps(src)
+
+    #
+
+    pom_prj = pg.Project(
+        group_id,
+        name,
+        DEFAULT_PROJECT_VERSION,
+
+        name,
+
+        properties={
+            'maven.compiler.source': DEFAULT_JAVA_VERSION,
+            'maven.compiler.target': DEFAULT_JAVA_VERSION,
+        },
+
+        dependencies=[
+            pg.Dependency(*dep.split(':'))
+            for dep in deps
+        ],
+    )
+
+    pom_xml = pg.render_project_xml(pom_prj)
+
+    #
+
+    smj_dir = os.path.join(root_dir, 'src', 'main', 'java')
+    sp_dir = smj_dir
+    for gi_part in group_id_parts:
+        sp_dir = os.path.join(sp_dir, gi_part)
+    os.makedirs(sp_dir)
+
+    with open(os.path.join(sp_dir, os.path.basename(src_file)), 'w') as f:
+        f.write(src)
+
+    with open(os.path.join(root_dir, 'pom.xml'), 'w') as f:
+        f.write(pom_xml)
+
+    #
+
+    return pom_prj
+
+
+##
+
+
+class Cli(ap.Cli):
+    @ap.cmd(
+        ap.arg('--cwd'),
+        ap.arg('--java'),
+        ap.arg('src-file'),
+        ap.arg('args', nargs=ap.REMAINDER),
+    )
+    def run(self) -> int:
+        src_file = self.args.src_file
+
+        #
+
+        with open(src_file) as f:
+            src = f.read()
+
+        #
+
+        deps = scan_jdeps(src)
+
+        #
+
+        if not deps:
+            proc = subprocess.run(
+                [
+                    self.args.java or 'java',
+                    src_file,
+                    *self.args.args,
+                ],
+                cwd=self.args.cwd,
+                check=False,
+            )
+
+            return proc.returncode
+
+        #
+
+        tmp_dir = tempfile.mkdtemp()
+        try:
+            pom_prj = build_maven_project(
+                tmp_dir,
+                src_file,
+                deps=deps,
+            )
+
+            proc = subprocess.run(
+                [
+                    'mvn',
+                    '-q',
+                    'compile',
+                ],
+                cwd=tmp_dir,
+                check=False,
+            )
+
+            if rc := proc.returncode:
+                return rc
+
+            cp_out = subprocess.check_output(
+                [
+                    'mvn',
+                    '-q',
+                    'dependency:build-classpath',
+                    '-Dmdep.includeScope=runtime',
+                    '-Dmdep.outputFile=/dev/stdout',
+                ],
+                cwd=tmp_dir,
+            )
+
+            cp = os.path.join(tmp_dir, 'target/classes')
+
+            if cp_out:
+                cp += ':' + cp_out.decode().strip()
+
+            proc = subprocess.run(
+                [
+                    self.args.java or 'java',
+                    '-cp',
+                    cp,
+                    f'{pom_prj.group_id}.{pom_prj.name}',
+                    *self.args.args,
+                ],
+                cwd=self.args.cwd,
+                check=False,
+            )
+
+            return proc.returncode
+
+        finally:
+            shutil.rmtree(tmp_dir)
+
+        return proc.returncode  # type: ignore[unreachable]  # noqa
+
+    @ap.cmd(
+        ap.arg('src-file'),
+    )
+    def ij(self) -> None:
+        src_file = self.args.src_file
+        src_file_name = os.path.basename(src_file)
+        prj_name = src_file_name.rpartition('.')[0]
+
+        tmp_dir = tempfile.mkdtemp(f'__{prj_name}')
+
+        build_maven_project(tmp_dir, src_file)
+
+        ij.open_ide(tmp_dir, ide=ij.Ide.IDEA)
+
+
+def _main() -> None:
+    Cli().cli_run_and_exit()
+
+
+if __name__ == '__main__':
+    _main()

omdev-0.0.0.dev526/omdev/java/pomgen.py

@@ -0,0 +1,240 @@
+import functools
+import typing as ta
+import xml.etree.ElementTree as ET
+
+from omlish import check
+from omlish import dataclasses as dc
+
+from .xml import append_xml_tail
+from .xml import append_xml_val
+from .xml import indent_xml
+from .xml import render_xml_node_head
+
+
+##
+
+
+@functools.singledispatch
+def make_xml(obj: ta.Any) -> ET.Element | None:
+    raise TypeError(obj)
+
+
+##
+
+
+@dc.dataclass()
+class Dependency:
+    group_id: str
+    artifact_id: str
+    version: str
+
+    _: dc.KW_ONLY
+
+    type: str | None = None
+    scope: str | None = None
+
+
+@make_xml.register
+def make_dependency_xml(obj: Dependency) -> ET.Element:
+    el = ET.Element('dependency')
+
+    append_xml_val(el, 'groupId', obj.group_id)
+    append_xml_val(el, 'artifactId', obj.artifact_id)
+    append_xml_val(el, 'version', obj.version)
+
+    if obj.type is not None:
+        append_xml_val(el, 'type', obj.type)
+    if obj.scope is not None:
+        append_xml_val(el, 'scope', obj.scope)
+
+    return el
+
+
+#
+
+
+@dc.dataclass(kw_only=True)
+class DependencyManagement:
+    dependencies: list[Dependency] = dc.field(default_factory=list)
+
+
+@make_xml.register
+def make_dependency_management_xml(obj: DependencyManagement) -> ET.Element | None:
+    if not obj.dependencies:
+        return None
+
+    el = ET.Element('dependencyManagement')
+
+    for dep in obj.dependencies:
+        if len(el):
+            append_xml_tail(el[-1], '\n')
+        el.append(make_dependency_xml(dep))
+
+    return el
+
+
+##
+
+
+@dc.dataclass()
+class Plugin:
+    group_id: str | None
+    artifact_id: str
+    version: str
+
+    _: dc.KW_ONLY
+
+    extensions: bool | None = None
+
+    executions: list[ta.Mapping[str, ta.Any]] | None = None
+
+    configuration: dict[str, ta.Any] = dc.field(default_factory=dict)
+
+
+@make_xml.register
+def make_plugin_xml(obj: Plugin) -> ET.Element:
+    el = ET.Element('plugin')
+
+    if obj.group_id is not None:
+        append_xml_val(el, 'groupId', obj.group_id)
+    append_xml_val(el, 'artifactId', obj.artifact_id)
+    append_xml_val(el, 'version', obj.version)
+
+    if obj.extensions is not None:
+        append_xml_val(el, 'extensions', 'true' if obj.extensions else 'false')
+
+    if obj.executions:
+        append_xml_val(ET.SubElement(el, 'executions'), 'execution', obj.executions)
+
+    if obj.configuration:
+        append_xml_val(el, 'configuration', obj.configuration)
+
+    return el
+
+
+#
+
+
+@dc.dataclass(kw_only=True)
+class PluginManagement:
+    plugins: list[Plugin] = dc.field(default_factory=list)
+
+
+@make_xml.register
+def make_plugin_management_xml(obj: PluginManagement) -> ET.Element | None:
+    if not obj.plugins:
+        return None
+
+    el = ET.Element('pluginManagement')
+
+    for pg in obj.plugins:
+        if len(el):
+            append_xml_tail(el[-1], '\n')
+        el.append(make_plugin_xml(pg))
+
+    return el
+
+
+#
+
+
+@dc.dataclass(kw_only=True)
+class Build:
+    plugin_management: PluginManagement = dc.field(default_factory=lambda: PluginManagement())
+
+
+@make_xml.register
+def make_build_xml(obj: Build) -> ET.Element | None:
+    if (pm_el := make_plugin_management_xml(obj.plugin_management)) is None:
+        return None
+
+    el = ET.Element('build')
+    el.append(pm_el)
+    return el
+
+
+##
+
+
+@dc.dataclass()
+class Project:
+    group_id: str
+    artifact_id: str
+    version: str
+
+    name: str
+
+    _: dc.KW_ONLY
+
+    DEFAULT_MODEL_VERSION: ta.ClassVar[str] = '4.0.0'
+    model_version: str = DEFAULT_MODEL_VERSION
+
+    properties: ta.Mapping[str, str | int | float | bool] | None = None
+
+    dependency_management: DependencyManagement = dc.field(default_factory=lambda: DependencyManagement())
+
+    dependencies: list[Dependency] = dc.field(default_factory=list)
+
+    build: Build = dc.field(default_factory=lambda: Build())
+
+
+@make_xml.register
+def make_project_xml(obj: Project) -> ET.Element:
+    el = ET.Element('project')
+
+    append_xml_val(el, 'modelVersion', obj.model_version, tail='\n')
+
+    append_xml_val(el, 'groupId', obj.group_id)
+    append_xml_val(el, 'artifactId', obj.artifact_id)
+    append_xml_val(el, 'version', obj.version, tail='\n')
+
+    append_xml_val(el, 'name', obj.name)
+
+    if obj.properties:
+        append_xml_tail(el[-1], '\n')
+        append_xml_val(el, 'properties', obj.properties)
+
+    if (dm_el := make_dependency_management_xml(obj.dependency_management)) is not None:
+        append_xml_tail(el[-1], '\n')
+        el.append(dm_el)
+
+    if obj.dependencies:
+        append_xml_tail(el[-1], '\n')
+        deps_el = ET.SubElement(el, 'dependencies')
+
+        for dep in obj.dependencies:
+            if len(deps_el):
+                append_xml_tail(deps_el[-1], '\n')
+            deps_el.append(make_dependency_xml(dep))
+
+    if (bld_el := make_build_xml(obj.build)) is not None:
+        append_xml_tail(el[-1], '\n')
+        el.append(bld_el)
+
+    return el
+
+
+def build_project_xml_attrs(prj: Project) -> ta.Mapping[str, str]:
+    return {
+        'xmlns': f'http://maven.apache.org/POM/{prj.model_version}',
+        'xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance',
+        'xsi:schemaLocation': ' '.join([
+            f'http://maven.apache.org/POM/{prj.model_version}',
+            f'http://maven.apache.org/xsd/maven-{prj.model_version}.xsd',
+        ]),
+    }
+
+
+##
+
+
+def render_project_xml(prj: Project, *, indent: str = '  ') -> str:
+    root = check.not_none(make_xml(prj))
+    indent_xml(root, indent, keep_space_tails=True)
+    xml_str = ET.tostring(root, encoding='utf-8', xml_declaration=True).decode('utf-8')
+
+    head_atts = build_project_xml_attrs(prj)
+    prj_head = render_xml_node_head('project', head_atts, indent=indent)
+    xml_str = xml_str.replace('<project>', prj_head, 1)
+
+    return xml_str

omdev-0.0.0.dev526/omdev/java/xml.py

@@ -0,0 +1,119 @@
+"""
+TODO:
+ -> omlish.formats.xml
+"""
+import typing as ta
+import xml.etree.ElementTree as ET
+import xml.sax.saxutils
+
+
+##
+
+
+def append_xml_tail(el: ET.Element, tail: str, *, delim: str = '') -> ET.Element:
+    el.tail = ((el.tail + delim) if el.tail else '') + tail
+    return el
+
+
+def scalar_to_xml_text(obj: ta.Any) -> str:
+    if isinstance(obj, bool):
+        return 'true' if obj else 'false'
+
+    elif isinstance(obj, (int, float, str)):
+        return str(obj)
+
+    else:
+        raise TypeError(obj)
+
+
+def val_to_xml(tag: str, obj: ta.Any, *, tail: str | None = None) -> ET.Element:
+    el = ET.Element(tag)
+
+    if isinstance(obj, dict):
+        for k, v in obj.items():
+            el.append(val_to_xml(k, v))
+
+    elif isinstance(obj, list):
+        for item in obj:
+            el.append(val_to_xml(tag, item))
+
+    else:
+        el.text = scalar_to_xml_text(obj)
+
+    if tail is not None:
+        el.tail = tail
+
+    return el
+
+
+def append_xml_val(parent: ET.Element, tag: str, val: ta.Any, *, tail: str | None = None) -> ET.Element:
+    el = val_to_xml(tag, val, tail=tail)
+    parent.append(el)
+    return el
+
+
+def indent_xml(
+        root: ET.Element,
+        space: str = '  ',
+        level: int = 0,
+        *,
+        keep_space_tails: bool = False,
+) -> None:
+    """
+    Indent an XML document by inserting newlines and indentation space after elements.
+
+    *root* is the ElementTree or Element to modify.  The (root) element itself will not be changed, but the tail text of
+    all elements in its subtree will be adapted.
+
+    *space* is the whitespace to insert for each indentation level, two space characters by default.
+
+    *level* is the initial indentation level. Setting this to a higher value than 0 can be used for indenting subtrees
+    that are more deeply nested inside of a document.
+    """
+
+    if isinstance(root, ET.ElementTree):
+        root = root.getroot()
+    if level < 0:
+        raise ValueError(f'Initial indentation level must be >= 0, got {level}')
+    if not len(root):
+        return
+
+    # Reduce the memory consumption by reusing indentation strings.
+    indentations = ['\n' + level * space]
+
+    def rec(el: ET.Element, level: int) -> None:
+        # Start a new indentation level for the first child.
+        child_level = level + 1
+        try:
+            child_indentation = indentations[child_level]
+        except IndexError:
+            child_indentation = indentations[level] + space
+            indentations.append(child_indentation)
+
+        if not el.text or not el.text.strip():
+            el.text = child_indentation
+
+        for child in el:
+            if len(child):
+                rec(child, child_level)
+            if keep_space_tails and child.tail and not child.tail.strip():
+                child.tail += child_indentation
+            elif not child.tail or not child.tail.strip():
+                child.tail = child_indentation
+
+        # Dedent after the last child by overwriting the previous indentation.
+        if not child.tail.strip():  # type: ignore[union-attr]
+            child.tail = indentations[level]
+
+    rec(root, 0)
+
+
+def render_xml_node_head(tag: str, atts: ta.Mapping[str, str], *, indent: str = '  ') -> str:
+    if not atts:
+        return f'<{tag}>'
+
+    return '\n'.join([
+        f'<{tag}',
+        *[f'{indent}{k}={xml.sax.saxutils.quoteattr(v)}' for k, v in atts.items()],
+        '>',
+    ])