omdev 0.0.0.dev525__tar.gz → 0.0.0.dev527__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: omdev
-Version: 0.0.0.dev525
+Version: 0.0.0.dev527
 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.dev527
 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.dev527}/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.dev527/omdev/dockerdev/config.toml

@@ -0,0 +1,36 @@
+base_image = 'ubuntu:24.04'
+
+dep_sets = [
+    'system',
+    'python',
+    'x11',
+]
+
+jdks = [
+    'zulu21-ca-jdk',
+    'zulu25-ca-jdk',
+]
+
+go_version = '1.26.0'
+
+zig_version = '0.15.2'
+
+nvm_versions = [
+    '20',
+    '22',
+    '25',
+]
+
+pyenv_version_keys = [
+    '8',
+    '13',
+    '14',
+]
+
+config_files = [
+    '.gdbinit',
+    '.tmux.conf',
+    '.vimrc',
+]
+
+workdir = '/omlish'

omdev-0.0.0.dev527/omdev/dockerdev/gen.py

@@ -0,0 +1,186 @@
+"""
+FIXME:
+ - zipsafe / resourcey, but still hard refs .versions file in repo root lol
+
+TODO:
+ - per-feature config, obv
+
+====
+
+docker run --rm -it "$(docker build -q -f x/dockerdev/Dockerfile .)" bash
+"""
+import io
+import tomllib
+import typing as ta
+
+from omlish import dataclasses as dc
+from omlish import lang
+from omlish import marshal as msh
+
+from .content import LazyContent
+from .content import Resource
+from .helpers import APT_CACHE_MOUNTS
+from .helpers import fragment_section
+from .helpers import read_versions_file_versions
+from .helpers import render_apt_install_dep_sets
+from .ops import Cmd
+from .ops import Entrypoint
+from .ops import Env
+from .ops import From
+from .ops import Op
+from .ops import Run
+from .ops import Section
+from .ops import Workdir
+from .ops import Write
+from .rendering import render_op
+
+
+##
+
+
+@dc.dataclass(frozen=True)
+class Config:
+    base_image: str
+
+    workdir: str | None = None
+
+    _: dc.KW_ONLY
+
+    dep_sets: ta.Sequence[str] | None = None
+
+    jdks: ta.Sequence[str] | None = None
+
+    go_version: str | None = None
+
+    zig_version: str | None = None
+
+    nvm_versions: ta.Sequence[str] | None = None
+
+    pyenv_version_keys: ta.Sequence[str] | None = None
+
+    config_files: ta.Sequence[str] | None = None
+
+
+##
+
+
+def gen_ops(cfg: Config) -> ta.Sequence[Op]:
+    ops: list[Op] = [
+        From(cfg.base_image),
+    ]
+
+    # ops.append(Section('timestamp', [
+    #     Copy(src='docker/.timestamp', dst='/'),
+    # ]))
+
+    ops.append(Section('locale', [
+        Env([
+            ('LANG', 'en_US.UTF-8'),
+            ('LANGUAGE', 'en_US:en'),
+            ('LC_ALL', 'en_US.UTF-8'),
+        ]),
+    ]))
+
+    ops.append(Section('deps', [
+        Run(
+            [
+                Resource('fragments/apt.sh'),
+                LazyContent(lambda: render_apt_install_dep_sets(*(cfg.dep_sets or []))),
+            ],
+            cache_mounts=APT_CACHE_MOUNTS,
+        ),
+    ]))
+
+    ops.append(fragment_section(
+        'firefox',
+        cache_mounts=APT_CACHE_MOUNTS,
+    ))
+
+    ops.append(fragment_section(
+        'docker',
+        cache_mounts=APT_CACHE_MOUNTS,
+    ))
+
+    if cfg.jdks:
+        ops.append(fragment_section(
+            'jdk',
+            static_env={'JDKS': cfg.jdks},
+            cache_mounts=APT_CACHE_MOUNTS,
+        ))
+
+    ops.append(fragment_section('rust'))
+
+    if cfg.go_version is not None:
+        ops.append(fragment_section(
+            'go',
+            static_env={'GO_VERSION': cfg.go_version},
+        ))
+
+    if cfg.zig_version is not None:
+        ops.append(fragment_section(
+            'zig',
+            static_env={'ZIG_VERSION': cfg.zig_version},
+        ))
+
+    ops.append(fragment_section('vcpkg'))
+
+    if cfg.nvm_versions:
+        ops.append(fragment_section(
+            'nvm',
+            static_env={'NVM_VERSIONS': cfg.nvm_versions},
+        ))
+
+    if cfg.pyenv_version_keys:
+        ops.append(fragment_section(
+            'pyenv',
+            static_env=lambda: {
+                'PYENV_VERSIONS': list(read_versions_file_versions(*[
+                    f'PYTHON_{k}' for k in cfg.pyenv_version_keys
+                ]).values()),
+            },
+            cache_mounts=['/root/.pyenv_cache'],
+        ))
+
+    ops.append(fragment_section('sshd'))
+
+    # ops.append(Section('x11', [
+    #     Run('touch /root/.Xauthority'),
+    #     Write('/root/xu', Resource('xu')),
+    # ]))
+
+    if cfg.config_files:
+        ops.append(Section('configs', [
+            Write(f'/root/{n}', Resource(f'configs/{n}'))
+            for n in cfg.config_files
+        ]))
+
+    ops.append(Section('entrypoint', [
+        *([Workdir(cfg.workdir)] if cfg.workdir is not None else []),
+        Entrypoint(['dumb-init', '--']),
+        Cmd(['sh', '-c', 'echo "Ready" && sleep infinity']),
+    ]))
+
+    return ops
+
+
+##
+
+
+def _main() -> None:
+    cfg_src = lang.get_relative_resources(globals=globals())['config.toml'].read_text()
+    cfg_dct = tomllib.loads(cfg_src)
+    cfg = msh.unmarshal(cfg_dct, Config)
+
+    ops = gen_ops(cfg)
+
+    out = io.StringIO()
+    for i, section in enumerate(ops):
+        if i:
+            out.write('\n\n\n')
+        out.write(render_op(section))
+
+    print(out.getvalue())
+
+
+if __name__ == '__main__':
+    _main()

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

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

omdev-0.0.0.dev525/omdev/dockerdev/resources/fragments/rustup.sh → omdev-0.0.0.dev527/omdev/dockerdev/resources/fragments/rust.sh

@@ -1,3 +1,10 @@
 set -ex ;
 
 curl --proto '=https' --tlsv1.2 -sSf 'https://sh.rustup.rs' | sh -s -- -y ;
+
+$HOME/.cargo/bin/cargo install \
+\
+  cargo-edit \
+  rust-script \
+\
+;

omdev-0.0.0.dev527/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.dev527/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()