[Tooling] Port of generate_tests.py to Julia (#1111)

* Added helper scripts and modified generate_tests.py for Julia.

* Modified JinJa2 macros file for Julia tests.

* Added test template for acronym.

* Added generated test file for acronym.

* Added requirements.txt file for python scripts.

* Added JuliaFormatter toml file and a comment in Project toml.

* Removed refs to air (the r formatter).

* Renamed install check to jlfmt from JuliaFormatter, since it is the CLI that is checked for.

* Using subprocess to shell out and call jlfmt instead of using juliacall.

* Final touches to formatting settings and template (for now).

Author: BethanyG

.JuliaFormatter.toml

@@ -0,0 +1 @@
+style = "yas"

Project.toml

@@ -4,3 +4,5 @@ JSON = "682c06a0-de6a-54ab-a142-c8b1cf79cde6"
 Pkg = "44cfe95a-1eb2-52ea-b672-e2afdf69b78f"
 Test = "8dfed614-e22c-5e08-85e1-65c5234f0b40"
 Combinatorics = "861a8166-3701-5b0c-9a16-15d98fcdc6aa"
+#JuliaFormatter = "98e50ef6-434e-11e9-1051-2b60c6c9e899"
+

bin/data.py

@@ -0,0 +1,381 @@
+from enum import Enum
+from dataclasses import dataclass, asdict, fields
+import dataclasses
+from itertools import chain
+import json
+from pathlib import Path
+from typing import List, Any, Dict, Type
+
+# Tomli was subsumed into Python 3.11.x, but was renamed to to tomllib.
+# This avoids ci failures for Python < 3.11.2.
+try:
+    import tomllib
+except ModuleNotFoundError:
+    import tomli as tomllib
+
+
+
+def _custom_dataclass_init(self, *args, **kwargs):
+    # print(self.__class__.__name__, "__init__")
+    names = [field.name for field in fields(self)]
+    used_names = set()
+
+    # Handle positional arguments
+    for value in args:
+        try:
+            name = names.pop(0)
+        except IndexError:
+            raise TypeError(f"__init__() given too many positional arguments")
+        # print(f'setting {k}={v}')
+        setattr(self, name, value)
+        used_names.add(name)
+
+    # Handle keyword arguments
+    for name, value in kwargs.items():
+        if name in names:
+            # print(f'setting {k}={v}')
+            setattr(self, name, value)
+            used_names.add(name)
+        elif name in used_names:
+            raise TypeError(f"__init__() got multiple values for argument '{name}'")
+        else:
+            raise TypeError(
+                f"Unrecognized field '{name}' for dataclass {self.__class__.__name__}."
+                "\nIf this field is valid, please add it to the dataclass in data.py."
+                "\nIf adding an object-type field, please create a new dataclass for it."
+            )
+
+    # Check for missing positional arguments
+    missing = [
+        f"'{field.name}'" for field in fields(self)
+        if isinstance(field.default, dataclasses._MISSING_TYPE) and field.name not in used_names
+    ]
+    if len(missing) == 1:
+        raise TypeError(f"__init__() missing 1 required positional argument: {missing[0]}")
+    elif len(missing) == 2:
+        raise TypeError(f"__init__() missing 2 required positional arguments: {' and '.join(missing)}")
+    elif len(missing) != 0:
+        missing[-1] = f"and {missing[-1]}"
+        raise TypeError(f"__init__() missing {len(missing)} required positional arguments: {', '.join(missing)}")
+
+    # Run post init if available
+    if hasattr(self, "__post_init__"):
+        self.__post_init__()
+
+
+@dataclass
+class TrackStatus:
+    __init__ = _custom_dataclass_init
+
+    concept_exercises: bool = False
+    test_runner: bool = False
+    representer: bool = False
+    analyzer: bool = False
+
+
+class IndentStyle(str, Enum):
+    Space = "space"
+    Tab = "tab"
+
+
+@dataclass
+class TestRunnerSettings:
+    average_run_time: float = -1
+
+
+@dataclass
+class EditorSettings:
+    __init__ = _custom_dataclass_init
+
+    indent_style: IndentStyle = IndentStyle.Space
+    indent_size: int = 4
+    ace_editor_language: str = "python"
+    highlightjs_language: str = "python"
+
+    def __post_init__(self):
+        if isinstance(self.indent_style, str):
+            self.indent_style = IndentStyle(self.indent_style)
+
+
+class ExerciseStatus(str, Enum):
+    Active = "active"
+    WIP = "wip"
+    Beta = "beta"
+    Deprecated = "deprecated"
+
+
+@dataclass
+class ExerciseFiles:
+    __init__ = _custom_dataclass_init
+
+    solution: List[str]
+    test: List[str]
+    editor: List[str] = None
+    exemplar: List[str] = None
+
+
+    # practice exercises are different
+    example: List[str] = None
+
+    def __post_init__(self):
+        if self.exemplar is None:
+            if self.example is None:
+                raise ValueError(
+                    "exercise config must have either files.exemplar or files.example"
+                )
+            else:
+                self.exemplar = self.example
+                delattr(self, "example")
+        elif self.example is not None:
+            raise ValueError(
+                "exercise config must have either files.exemplar or files.example, but not both"
+            )
+
+
+@dataclass
+class ExerciseConfig:
+    __init__ = _custom_dataclass_init
+
+    files: ExerciseFiles
+    authors: List[str] = None
+    forked_from: str = None
+    contributors: List[str] = None
+    language_versions: List[str] = None
+    test_runner: bool = True
+    source: str = None
+    source_url: str = None
+    blurb: str = None
+    icon: str = None
+
+    def __post_init__(self):
+        if isinstance(self.files, dict):
+            self.files = ExerciseFiles(**self.files)
+        for attr in ["authors", "contributors", "language_versions"]:
+            if getattr(self, attr) is None:
+                setattr(self, attr, [])
+
+    @classmethod
+    def load(cls, config_file: Path) -> "ExerciseConfig":
+        with config_file.open() as f:
+            return cls(**json.load(f))
+
+
+@dataclass
+class ExerciseInfo:
+    __init__ = _custom_dataclass_init
+
+    path: Path
+    slug: str
+    name: str
+    uuid: str
+    prerequisites: List[str]
+    type: str = "practice"
+    status: ExerciseStatus = ExerciseStatus.Active
+
+    # concept only
+    concepts: List[str] = None
+
+    # practice only
+    difficulty: int = 1
+    topics: List[str] = None
+    practices: List[str] = None
+
+    def __post_init__(self):
+        if self.concepts is None:
+            self.concepts = []
+        if self.topics is None:
+            self.topics = []
+        if self.practices is None:
+            self.practices = []
+        if isinstance(self.status, str):
+            self.status = ExerciseStatus(self.status)
+
+    @property
+    def solution_stub(self):
+        return next(
+            (
+                p
+                for p in self.path.glob("*.py")
+                if not p.name.endswith("_test.py") and p.name != "example.py"
+            ),
+            None,
+        )
+
+    @property
+    def helper_file(self):
+        return next(self.path.glob("*_data.py"), None)
+
+    @property
+    def test_file(self):
+        return next(self.path.glob("*_test.py"), None)
+
+    @property
+    def meta_dir(self):
+        return self.path / ".meta"
+
+    @property
+    def exemplar_file(self):
+        if self.type == "concept":
+            return self.meta_dir / "exemplar.py"
+        return self.meta_dir / "example.py"
+
+    @property
+    def template_path(self):
+        return self.meta_dir / "template.j2"
+
+    @property
+    def config_file(self):
+        return self.meta_dir / "config.json"
+
+    def load_config(self) -> ExerciseConfig:
+        return ExerciseConfig.load(self.config_file)
+
+
+@dataclass
+class Exercises:
+    __init__ = _custom_dataclass_init
+
+    concept: List[ExerciseInfo]
+    practice: List[ExerciseInfo]
+    foregone: List[str] = None
+
+    def __post_init__(self):
+        if self.foregone is None:
+            self.foregone = []
+        for attr_name in ["concept", "practice"]:
+            base_path = Path("exercises") / attr_name
+            setattr(
+                self,
+                attr_name,
+                [
+                    (
+                        ExerciseInfo(path=(base_path / e["slug"]), type=attr_name, **e)
+                        if isinstance(e, dict)
+                        else e
+                    )
+                    for e in getattr(self, attr_name)
+                ],
+            )
+
+    def all(self, status_filter={ExerciseStatus.Active, ExerciseStatus.Beta}):
+        return [
+            e for e in chain(self.concept, self.practice) if e.status in status_filter
+        ]
+
+
+@dataclass
+class Concept:
+    __init__ = _custom_dataclass_init
+
+    uuid: str
+    slug: str
+    name: str
+
+
+@dataclass
+class Feature:
+    __init__ = _custom_dataclass_init
+
+    title: str
+    content: str
+    icon: str
+
+
+@dataclass
+class FilePatterns:
+    __init__ = _custom_dataclass_init
+
+    solution: List[str]
+    test: List[str]
+    example: List[str]
+    exemplar: List[str]
+    editor: List[str] = None
+
+
+
+@dataclass
+class Config:
+    __init__ = _custom_dataclass_init
+
+    language: str
+    slug: str
+    active: bool
+    status: TrackStatus
+    blurb: str
+    version: int
+    online_editor: EditorSettings
+    exercises: Exercises
+    concepts: List[Concept]
+    key_features: List[Feature] = None
+    tags: List[Any] = None
+    test_runner: TestRunnerSettings = None
+    files: FilePatterns = None
+
+    def __post_init__(self):
+        if isinstance(self.status, dict):
+            self.status = TrackStatus(**self.status)
+        if isinstance(self.online_editor, dict):
+            self.online_editor = EditorSettings(**self.online_editor)
+        if isinstance(self.test_runner, dict):
+            self.test_runner = TestRunnerSettings(**self.test_runner)
+        if isinstance(self.exercises, dict):
+            self.exercises = Exercises(**self.exercises)
+        if isinstance(self.files, dict):
+            self.files = FilePatterns(**self.files)
+        self.concepts = [
+            (Concept(**c) if isinstance(c, dict) else c) for c in self.concepts
+        ]
+        if self.key_features is None:
+            self.key_features = []
+        if self.tags is None:
+            self.tags = []
+
+    @classmethod
+    def load(cls, path="config.json"):
+        try:
+            with Path(path).open() as f:
+                return cls(**json.load(f))
+        except IOError:
+            print(f"FAIL: {path} file not found")
+            raise SystemExit(1)
+        except TypeError as ex:
+            print(f"FAIL: {ex}")
+            raise SystemExit(1)
+
+
+@dataclass
+class TestCaseTOML:
+    __init__ = _custom_dataclass_init
+
+    uuid: str
+    description: str
+    include: bool = True
+    comment: str = ''
+
+
+@dataclass
+class TestsTOML:
+    __init__ = _custom_dataclass_init
+
+    cases: Dict[str, TestCaseTOML]
+
+    @classmethod
+    def load(cls, toml_path: Path):
+        with toml_path.open("rb") as f:
+            data = tomllib.load(f)
+        return cls({uuid: TestCaseTOML(uuid, *opts) for
+                    uuid, opts in
+                    data.items() if
+                    opts.get('include', None) is not False})
+
+
+if __name__ == "__main__":
+
+    class CustomEncoder(json.JSONEncoder):
+        def default(self, obj):
+            if isinstance(obj, Path):
+                return str(obj)
+            return json.JSONEncoder.default(self, obj)
+
+    config = Config.load()
+    print(json.dumps(asdict(config), cls=CustomEncoder, indent=2))