uml-gen 1.0.0__tar.gz

uml_gen-1.0.0/LICENSE.txt

@@ -0,0 +1,44 @@
+UML Tool License Agreement (Non-Commercial Use)
+
+Copyright (c) 2013 petercai
+
+1. Grant of License
+
+Permission is hereby granted to any individual or organization to use, copy,
+modify, and distribute this software for personal, educational, or other
+non-commercial purposes, free of charge.
+
+2. Commercial Use Restriction
+
+Commercial use of this software is strictly prohibited without a valid
+commercial license obtained from the author.
+
+Commercial use includes, but is not limited to:
+
+- Use within a for-profit organization
+- Use in a production environment
+- Offering the software as a service (SaaS)
+- Integration into a paid product or service
+- Internal business usage
+
+3. Commercial License
+
+Organizations or individuals wishing to use this software for commercial
+purposes must obtain a separate commercial license.
+
+For commercial licensing inquiries, please contact:
+petercaica@hotmail.com
+
+4. Redistribution
+
+Redistribution of the software is permitted for non-commercial purposes only,
+provided that this license is included.
+
+5. No Warranty
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED.
+
+6. Termination
+
+Violation of this license will result in automatic termination of rights.

uml_gen-1.0.0/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: uml-gen
+Version: 1.0.0
+Summary: Generate UML diagrams from source code.
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: tree-sitter>=0.25.2
+Requires-Dist: tree-sitter-java>=0.23.5
+Dynamic: license-file

uml_gen-1.0.0/pyproject.toml

@@ -0,0 +1,32 @@
+[project]
+name = "uml-gen"
+version = "1.0.0"
+description = "Generate UML diagrams from source code."
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = [
+    "pyyaml>=6.0.3",
+    "tree-sitter>=0.25.2",
+    "tree-sitter-java>=0.23.5",
+]
+
+[project.scripts]
+umlc     = "umlgen_pkg.umlc:main"
+umls     = "umlgen_pkg.umls:main"
+umlc-gen = "umlgen_pkg.umlc_gen:main"
+umls-gen = "umlgen_pkg.umls_gen:main"
+
+[build-system]
+requires = ["setuptools>=64"]
+build-backend = "setuptools.build_meta"
+
+# Map package roots to uml/.gen.
+[tool.setuptools.package-dir]
+"" = "uml/.gen"
+
+# Auto-discover packages (umlgen_pkg and umlgen_pkg.frontends).
+[tool.setuptools.packages.find]
+where = ["uml/.gen"]
+
+[tool.setuptools.package-data]
+umlgen_pkg = ["mark.txt"]

uml_gen-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

uml_gen-1.0.0/uml/.gen/uml_gen.egg-info/PKG-INFO

@@ -0,0 +1,11 @@
+Metadata-Version: 2.4
+Name: uml-gen
+Version: 1.0.0
+Summary: Generate UML diagrams from source code.
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: pyyaml>=6.0.3
+Requires-Dist: tree-sitter>=0.25.2
+Requires-Dist: tree-sitter-java>=0.23.5
+Dynamic: license-file

uml_gen-1.0.0/uml/.gen/uml_gen.egg-info/SOURCES.txt

@@ -0,0 +1,29 @@
+LICENSE.txt
+pyproject.toml
+uml/.gen/uml_gen.egg-info/PKG-INFO
+uml/.gen/uml_gen.egg-info/SOURCES.txt
+uml/.gen/uml_gen.egg-info/dependency_links.txt
+uml/.gen/uml_gen.egg-info/entry_points.txt
+uml/.gen/uml_gen.egg-info/requires.txt
+uml/.gen/uml_gen.egg-info/top_level.txt
+uml/.gen/umlgen_pkg/__init__.py
+uml/.gen/umlgen_pkg/ir_models.py
+uml/.gen/umlgen_pkg/java_sequence_index.py
+uml/.gen/umlgen_pkg/java_tree_sitter_frontend.py
+uml/.gen/umlgen_pkg/java_tree_sitter_ir.py
+uml/.gen/umlgen_pkg/java_tree_sitter_support.py
+uml/.gen/umlgen_pkg/mark.txt
+uml/.gen/umlgen_pkg/umlc.py
+uml/.gen/umlgen_pkg/umlc_gen.py
+uml/.gen/umlgen_pkg/umlgen_cli.py
+uml/.gen/umlgen_pkg/umlgen_file_header.py
+uml/.gen/umlgen_pkg/umlgen_legend.py
+uml/.gen/umlgen_pkg/umlgen_matched.py
+uml/.gen/umlgen_pkg/umlgen_rule_match.py
+uml/.gen/umlgen_pkg/umlgen_yaml.py
+uml/.gen/umlgen_pkg/umls.py
+uml/.gen/umlgen_pkg/umls_gen.py
+uml/.gen/umlgen_pkg/umls_hierarchy.py
+uml/.gen/umlgen_pkg/frontends/__init__.py
+uml/.gen/umlgen_pkg/frontends/base.py
+uml/.gen/umlgen_pkg/frontends/registry.py

uml_gen-1.0.0/uml/.gen/uml_gen.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

uml_gen-1.0.0/uml/.gen/uml_gen.egg-info/entry_points.txt

@@ -0,0 +1,5 @@
+[console_scripts]
+umlc = umlgen_pkg.umlc:main
+umlc-gen = umlgen_pkg.umlc_gen:main
+umls = umlgen_pkg.umls:main
+umls-gen = umlgen_pkg.umls_gen:main

uml_gen-1.0.0/uml/.gen/uml_gen.egg-info/requires.txt

@@ -0,0 +1,3 @@
+pyyaml>=6.0.3
+tree-sitter>=0.25.2
+tree-sitter-java>=0.23.5

uml_gen-1.0.0/uml/.gen/uml_gen.egg-info/top_level.txt

@@ -0,0 +1 @@
+umlgen_pkg

uml_gen-1.0.0/uml/.gen/umlgen_pkg/__init__.py

@@ -0,0 +1 @@
+"""uml-gen package."""

uml_gen-1.0.0/uml/.gen/umlgen_pkg/frontends/__init__.py

@@ -0,0 +1 @@
+"""Frontend contracts and registry for umlgen language parsers."""

uml_gen-1.0.0/uml/.gen/umlgen_pkg/frontends/base.py

@@ -0,0 +1,32 @@
+#!/usr/bin/env python3
+"""Plugin contracts for umlgen frontends."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Protocol, runtime_checkable
+
+
+@runtime_checkable
+class JavaClassIndexer(Protocol):
+    """Contract for Java class-diagram source indexers."""
+
+    def __call__(self, workspace: Path, src_root: Path) -> tuple[dict[str, Any], dict[str, list[Any]]]:
+        """Return (by_fqcn, by_simple_name) indices."""
+
+
+@runtime_checkable
+class JavaSequenceIndexer(Protocol):
+    """Contract for Java sequence-diagram source indexers."""
+
+    def __call__(self, workspace: Path, src_root: Path) -> Any:
+        """Return a sequence index object compatible with umls_gen consumers."""
+
+
+@dataclass(frozen=True)
+class FrontendSelection:
+    """Selected frontend pair for class/sequence generation."""
+
+    class_indexer: JavaClassIndexer | None
+    sequence_indexer: JavaSequenceIndexer | None

uml_gen-1.0.0/uml/.gen/umlgen_pkg/frontends/registry.py

@@ -0,0 +1,44 @@
+#!/usr/bin/env python3
+"""Frontend registry for parser selection and reserved parser placeholders."""
+
+from __future__ import annotations
+
+from umlgen_pkg.frontends.base import FrontendSelection
+
+try:
+    from umlgen_pkg.java_tree_sitter_frontend import (
+        index_source_tree as tree_sitter_sequence_indexer,
+        index_workspace_types as tree_sitter_class_indexer,
+    )
+except ImportError:  # pragma: no cover - optional dependency at runtime
+    tree_sitter_sequence_indexer = None
+    tree_sitter_class_indexer = None
+
+
+def _reserved_error(parser_name: str) -> ValueError:
+    return ValueError(
+        f"config.runtime.parser={parser_name} is reserved for a future bridge frontend and is not implemented yet"
+    )
+
+
+def resolve_java_frontend(parser_name: str) -> FrontendSelection:
+    parser = (parser_name or "legacy").strip()
+
+    if parser == "legacy":
+        return FrontendSelection(
+            class_indexer=None,
+            sequence_indexer=None,
+        )
+
+    if parser == "tree-sitter":
+        if tree_sitter_class_indexer is None or tree_sitter_sequence_indexer is None:
+            raise ValueError("tree-sitter parser selected but dependencies are not installed")
+        return FrontendSelection(
+            class_indexer=tree_sitter_class_indexer,
+            sequence_indexer=tree_sitter_sequence_indexer,
+        )
+
+    if parser in {"spoon", "ts-morph"}:
+        raise _reserved_error(parser)
+
+    raise ValueError(f"Unsupported parser: {parser}")

uml_gen-1.0.0/uml/.gen/umlgen_pkg/ir_models.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+"""Shared intermediate representation models for umlgen frontends."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class SourceRef:
+    """Stable source location reference."""
+
+    relpath: str
+    line: int
+
+
+@dataclass(frozen=True)
+class MethodCallIR:
+    """Call-site level IR for sequence generation."""
+
+    method_name: str
+    qualifier: str | None
+    source: SourceRef
+
+
+@dataclass(frozen=True)
+class FieldIR:
+    """Field/member IR."""
+
+    name: str
+    visibility: str
+    source: SourceRef
+
+
+@dataclass(frozen=True)
+class MethodIR:
+    """Method/constructor IR."""
+
+    name: str
+    visibility: str
+    source: SourceRef
+    return_type_names: tuple[str, ...] = ()
+    parameter_type_names: tuple[str, ...] = ()
+    calls: tuple[MethodCallIR, ...] = ()
+
+
+@dataclass(frozen=True)
+class TypeIR:
+    """Type-level IR shared by class and sequence frontends."""
+
+    language: str
+    kind: str
+    name: str
+    package: str
+    fqcn: str
+    source: SourceRef
+    extends_types: tuple[str, ...] = ()
+    implements_types: tuple[str, ...] = ()
+    dependency_types: tuple[str, ...] = ()
+    fields: tuple[FieldIR, ...] = ()
+    methods: tuple[MethodIR, ...] = ()
+
+
+@dataclass(frozen=True)
+class SourceIndexIR:
+    """Workspace-scoped IR index returned by language frontends."""
+
+    language: str
+    types: tuple[TypeIR, ...] = ()

uml_gen-1.0.0/uml/.gen/umlgen_pkg/java_sequence_index.py

@@ -0,0 +1,346 @@
+#!/usr/bin/env python3
+"""Minimal Java source index for sequence call-chain extraction."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+import re
+from pathlib import Path
+
+PACKAGE_RE = re.compile(r"^\s*package\s+([A-Za-z_$][\w$.]*)\s*;")
+TYPE_RE = re.compile(
+    r"^\s*(?:public|protected|private)?\s*(?:abstract\s+|final\s+)?"
+    r"(class|interface|enum|record)\s+([A-Za-z_$][\w$]*)\b"
+)
+METHOD_RE = re.compile(
+    r"^\s*(?:public|protected|private)?\s*(?:static\s+|final\s+|abstract\s+|synchronized\s+|default\s+)*"
+    r"(?:[A-Za-z_$][\w$<>\[\],.?\s]+\s+)?([A-Za-z_$][\w$]*)\s*\(([^)]*)\)"
+)
+FIELD_RE = re.compile(
+    r"^\s*(?:public|protected|private)?\s*(?:static\s+)?(?:final\s+)?"
+    r"([A-Za-z_$][\w$<>\[\],.?]*)\s+([a-zA-Z_$][\w$]*)\s*(?:=|;|,)"
+)
+LOCAL_VAR_RE = re.compile(
+    r"\b([A-Za-z_$][\w$<>\[\],.?]*)\s+([a-zA-Z_$][\w$]*)\s*(?:=|;|,)"
+)
+QUALIFIED_CALL_RE = re.compile(r"\b([A-Za-z_$][\w$]*)\s*\.\s*([A-Za-z_$][\w$]*)\s*\(([^)]*)\)")
+SIMPLE_CALL_RE = re.compile(r"(?<!\.)\b([A-Za-z_$][\w$]*)\s*\(([^)]*)\)")
+
+KEYWORDS = {
+    "if",
+    "for",
+    "while",
+    "switch",
+    "catch",
+    "return",
+    "throw",
+    "new",
+    "super",
+    "this",
+    "try",
+}
+
+
+@dataclass
+class MethodCall:
+    method_name: str
+    qualifier: str | None
+    call_line: int
+
+
+@dataclass
+class MethodDef:
+    type_fqcn: str
+    type_short_name: str
+    relpath: str
+    method_name: str
+    decl_line: int
+    calls: list[MethodCall] = field(default_factory=list)
+
+
+@dataclass
+class TypeDef:
+    fqcn: str
+    short_name: str
+    relpath: str
+    decl_line: int
+    extends_types: tuple[str, ...] = ()
+    implements_types: tuple[str, ...] = ()
+
+
+@dataclass
+class SequenceIndex:
+    types_by_fqcn: dict[str, TypeDef]
+    methods_by_key: dict[tuple[str, str], MethodDef]
+    methods_by_short_type: dict[str, list[MethodDef]]
+
+
+def _short_type(type_expr: str) -> str:
+    text = re.sub(r"<[^<>]*>", "", type_expr or "").replace("[]", "").strip()
+    if not text:
+        return ""
+    return text.split(".")[-1]
+
+
+def _find_package(lines: list[str]) -> str:
+    for line in lines:
+        matched = PACKAGE_RE.match(line)
+        if matched:
+            return matched.group(1)
+    return ""
+
+
+def _normalize_declared_type_name(raw: str) -> str:
+    text = re.sub(r"<[^<>]*>", "", (raw or "")).replace("[]", "").strip()
+    if not text:
+        return ""
+    return text.split(".")[-1]
+
+
+def _parse_declared_types(raw: str) -> tuple[str, ...]:
+    if not raw:
+        return ()
+    values: list[str] = []
+    for part in raw.split(","):
+        name = _normalize_declared_type_name(part)
+        if name and name not in values:
+            values.append(name)
+    return tuple(values)
+
+
+def _extract_parent_types_from_signature(signature: str) -> tuple[tuple[str, ...], tuple[str, ...]]:
+    text = re.sub(r"\s+", " ", signature)
+    extends_types: tuple[str, ...] = ()
+    implements_types: tuple[str, ...] = ()
+
+    # interface Foo extends A, B {
+    interface_match = re.search(r"\binterface\b\s+[A-Za-z_$][\w$]*\s+extends\s+([^\{]+)", text)
+    if interface_match:
+        extends_types = _parse_declared_types(interface_match.group(1))
+
+    # class Foo extends A implements B, C {
+    extends_match = re.search(r"\bclass\b\s+[A-Za-z_$][\w$]*\s+extends\s+([^\{\s]+(?:\s*<[^{}>]*>)?)", text)
+    if extends_match:
+        extends_types = _parse_declared_types(extends_match.group(1))
+
+    implements_match = re.search(r"\b(?:class|record)\b\s+[A-Za-z_$][\w$]*(?:\s+extends\s+[^\{]+?)?\s+implements\s+([^\{]+)", text)
+    if implements_match:
+        implements_types = _parse_declared_types(implements_match.group(1))
+
+    return extends_types, implements_types
+
+
+def _type_block_end(lines: list[str], start_line_index: int) -> int:
+    depth = 0
+    opened = False
+    for i in range(start_line_index, len(lines)):
+        for ch in lines[i]:
+            if ch == "{":
+                depth += 1
+                opened = True
+            elif ch == "}" and opened:
+                depth -= 1
+        if opened and depth == 0:
+            return i
+    return len(lines) - 1
+
+
+def _collect_fields(lines: list[str], start: int, end: int) -> dict[str, str]:
+    depth = 0
+    fields: dict[str, str] = {}
+
+    for i in range(start, end + 1):
+        line = lines[i]
+        current_depth = depth
+        if current_depth == 1:
+            match = FIELD_RE.match(line.strip())
+            if match:
+                fields[match.group(2)] = _short_type(match.group(1))
+
+        for ch in line:
+            if ch == "{":
+                depth += 1
+            elif ch == "}" and depth > 0:
+                depth -= 1
+
+    return fields
+
+
+def _parse_method_calls(
+    *,
+    lines: list[str],
+    method_start: int,
+    method_end: int,
+    method_name: str,
+    fields: dict[str, str],
+) -> list[MethodCall]:
+    calls: list[MethodCall] = []
+    local_types: dict[str, str] = {}
+
+    for i in range(method_start, method_end + 1):
+        raw = lines[i]
+        text = raw.strip()
+        if text.startswith("//"):
+            continue
+
+        local_decl = LOCAL_VAR_RE.search(text)
+        if local_decl:
+            local_types[local_decl.group(2)] = _short_type(local_decl.group(1))
+
+        for match in QUALIFIED_CALL_RE.finditer(text):
+            qualifier = match.group(1)
+            called = match.group(2)
+            if called in KEYWORDS:
+                continue
+            if called == method_name:
+                # recursive call is still useful
+                pass
+
+            resolved_qualifier = qualifier
+            if qualifier in local_types:
+                resolved_qualifier = local_types[qualifier]
+            elif qualifier in fields:
+                resolved_qualifier = fields[qualifier]
+
+            calls.append(MethodCall(method_name=called, qualifier=resolved_qualifier, call_line=i + 1))
+
+        for match in SIMPLE_CALL_RE.finditer(text):
+            called = match.group(1)
+            if called in KEYWORDS:
+                continue
+            if f".{called}(" in text:
+                continue
+            calls.append(MethodCall(method_name=called, qualifier=None, call_line=i + 1))
+
+    return calls
+
+
+def _parse_methods(
+    *,
+    lines: list[str],
+    type_fqcn: str,
+    type_short_name: str,
+    relpath: str,
+    start: int,
+    end: int,
+    fields: dict[str, str],
+) -> list[MethodDef]:
+    methods: list[MethodDef] = []
+    depth = 0
+    i = start
+
+    while i <= end:
+        line = lines[i]
+        current_depth = depth
+        text = line.strip()
+
+        if current_depth == 1 and "(" in text and not text.startswith(("if ", "for ", "while ", "switch ", "catch ")):
+            signature = text
+            sig_end = i
+            while ")" not in signature and sig_end + 1 <= end:
+                sig_end += 1
+                signature += " " + lines[sig_end].strip()
+
+            method_match = METHOD_RE.match(signature)
+            if method_match:
+                method_name = method_match.group(1)
+                body_start = sig_end
+                while body_start <= end and "{" not in lines[body_start]:
+                    body_start += 1
+                if body_start <= end:
+                    body_depth = 0
+                    body_end = body_start
+                    for j in range(body_start, end + 1):
+                        for ch in lines[j]:
+                            if ch == "{":
+                                body_depth += 1
+                            elif ch == "}" and body_depth > 0:
+                                body_depth -= 1
+                        if body_depth == 0 and j > body_start:
+                            body_end = j
+                            break
+
+                    methods.append(
+                        MethodDef(
+                            type_fqcn=type_fqcn,
+                            type_short_name=type_short_name,
+                            relpath=relpath,
+                            method_name=method_name,
+                            decl_line=i + 1,
+                            calls=_parse_method_calls(
+                                lines=lines,
+                                method_start=body_start,
+                                method_end=body_end,
+                                method_name=method_name,
+                                fields=fields,
+                            ),
+                        )
+                    )
+                    i = body_end
+
+        for ch in line:
+            if ch == "{":
+                depth += 1
+            elif ch == "}" and depth > 0:
+                depth -= 1
+
+        i += 1
+
+    return methods
+
+
+def index_source_tree(workspace: Path, src_root: Path) -> SequenceIndex:
+    java_files = sorted(p for p in src_root.rglob("*.java") if p.is_file())
+
+    types_by_fqcn: dict[str, TypeDef] = {}
+    methods_by_key: dict[tuple[str, str], MethodDef] = {}
+    methods_by_short_type: dict[str, list[MethodDef]] = {}
+
+    for java_file in java_files:
+        lines = java_file.read_text(encoding="utf-8", errors="ignore").splitlines()
+        package = _find_package(lines)
+        relpath = java_file.relative_to(workspace).as_posix()
+
+        for i, line in enumerate(lines):
+            type_match = TYPE_RE.match(line)
+            if not type_match:
+                continue
+
+            signature = line.strip()
+            sig_end = i
+            while "{" not in signature and sig_end + 1 < len(lines):
+                sig_end += 1
+                signature += " " + lines[sig_end].strip()
+            extends_types, implements_types = _extract_parent_types_from_signature(signature)
+
+            type_short_name = type_match.group(2)
+            type_fqcn = f"{package}.{type_short_name}" if package else type_short_name
+            type_end = _type_block_end(lines, i)
+            types_by_fqcn[type_fqcn] = TypeDef(
+                fqcn=type_fqcn,
+                short_name=type_short_name,
+                relpath=relpath,
+                decl_line=i + 1,
+                extends_types=extends_types,
+                implements_types=implements_types,
+            )
+
+            fields = _collect_fields(lines, i, type_end)
+            methods = _parse_methods(
+                lines=lines,
+                type_fqcn=type_fqcn,
+                type_short_name=type_short_name,
+                relpath=relpath,
+                start=i,
+                end=type_end,
+                fields=fields,
+            )
+            for method in methods:
+                methods_by_key[(method.type_fqcn, method.method_name)] = method
+                methods_by_short_type.setdefault(method.type_short_name, []).append(method)
+
+    return SequenceIndex(
+        types_by_fqcn=types_by_fqcn,
+        methods_by_key=methods_by_key,
+        methods_by_short_type=methods_by_short_type,
+    )