Implement language-specific overrides

tested/descriptions/converters.py

@@ -1,9 +1,11 @@
+from abc import ABC, abstractmethod
 from functools import partial
-from typing import cast
+from typing import Callable, cast
 
 from attr import dataclass
 from jinja2 import Template
 from marko import Markdown
+from typing_extensions import override
 
 from tested.configs import Bundle
 from tested.datatypes import AdvancedTypes, AllTypes, string_to_type
@@ -20,11 +22,33 @@
  conventionalize_property,
 )
 from tested.languages.generation import NestedTypeDeclaration, generate_type_declaration
+from tested.testsuite import LanguageMapping
 from tested.utils import get_args
 
 
+class Datatype(ABC):
+ @abstractmethod
+ def __str__(self) -> str:
+ raise NotImplementedError()
+
+ @property
+ @abstractmethod
+ def simple(self) -> str:
+ raise NotImplementedError()
+
+ @property
+ @abstractmethod
+ def singular(self) -> str:
+ raise NotImplementedError()
+
+ @property
+ @abstractmethod
+ def plural(self) -> str:
+ raise NotImplementedError()
+
+
 @dataclass
-class Datatype:
+class GenericDatatype(Datatype):
  locale: str
  language: Language
  type_: AllTypes
@@ -58,6 +82,7 @@ def _types(self) -> list[str]:
  ), f"Could not find concrete type for {self.type_} in {self.language.__class__.__name__}"
  return result
 
+ @override
  def __str__(self) -> str:
  types = self._types()
  types = [f"`{x}`" for x in types]
@@ -67,27 +92,83 @@ def __str__(self) -> str:
  )
 
  @property
+ @override
  def simple(self) -> str:
  if len(self.others):
  return generate_type_declaration(self.language, (self.type_, self.others))
  else:
  return generate_type_declaration(self.language, self.type_)
 
  @property
+ @override
  def singular(self) -> str:
  return get_i18n_string(f"types.singular.{self.type_}")
 
  @property
+ @override
  def plural(self) -> str:
  return get_i18n_string(f"types.singular.{self.type_}")
 
 
-def construct_datatype(
- locale: str, language: Language, type_: str, *others: NestedTypeDeclaration
+@dataclass
+class LanguageSpecificDatatype(Datatype):
+ result: str
+
+ @override
+ def __str__(self) -> str:
+ return self.result
+
+ @property
+ @override
+ def simple(self) -> str:
+ return self.result
+
+ @property
+ @override
+ def singular(self) -> str:
+ return self.result
+
+ @property
+ @override
+ def plural(self) -> str:
+ return self.result
+
+
+def _construct_datatype(
+ bundle: Bundle, type_: str | LanguageMapping, *others: NestedTypeDeclaration
 ) -> Datatype:
- enum_type = string_to_type(type_)
- # noinspection PyTypeChecker
- return Datatype(locale=locale, language=language, type_=enum_type, others=others)
+ if isinstance(type_, dict):
+ assert bundle.config.programming_language in type_, (
+ f"Cannot convert to {bundle.config.programming_language}, as a language-specific"
+ f" type was request while not provided. The provided languages are {type_.keys()}."
+ )
+ return LanguageSpecificDatatype(
+ result=type_[bundle.config.programming_language]
+ )
+ else:
+ enum_type = string_to_type(type_)
+ # noinspection PyTypeChecker
+ return GenericDatatype(
+ locale=bundle.config.natural_language,
+ language=bundle.language,
+ type_=enum_type,
+ others=others,
+ )
+
+
+def _support_language_specific_arguments(
+ normal: Callable[[Language, str], str],
+ bundle: Bundle,
+ actual: str | LanguageMapping,
+) -> str:
+ if isinstance(actual, dict):
+ assert bundle.config.programming_language in actual, (
+ f"Cannot convert to {bundle.config.programming_language}, as a language-specific"
+ f" construct was request while not provided. The provided languages are {actual.keys()}."
+ )
+ return actual[bundle.config.programming_language]
+ else:
+ return normal(bundle.language, actual)
 
 
 def convert_templated_problem(bundle: Bundle, raw_description: str) -> str:
@@ -102,20 +183,33 @@ def convert_templated_problem(bundle: Bundle, raw_description: str) -> str:
  description_template = Template(
  source=raw_description, autoescape=False, keep_trailing_newline=True
  )
- language = bundle.language
  set_locale(bundle.config.natural_language)
  return description_template.render(
  # Conventionalize functions
- namespace=partial(conventionalize_namespace, language),
- function=partial(conventionalize_function, language),
- identifier=partial(conventionalize_identifier, language),
- property=partial(conventionalize_property, language),
- clazz=partial(conventionalize_class, language),
- global_identifier=partial(conventionalize_global_identifier, language),
+ namespace=partial(
+ _support_language_specific_arguments, conventionalize_namespace, bundle
+ ),
+ function=partial(
+ _support_language_specific_arguments, conventionalize_function, bundle
+ ),
+ identifier=partial(
+ _support_language_specific_arguments, conventionalize_identifier, bundle
+ ),
+ property=partial(
+ _support_language_specific_arguments, conventionalize_property, bundle
+ ),
+ clazz=partial(
+ _support_language_specific_arguments, conventionalize_class, bundle
+ ),
+ global_identifier=partial(
+ _support_language_specific_arguments,
+ conventionalize_global_identifier,
+ bundle,
+ ),
  # Access to the current programming language
  programming_language=bundle.config.programming_language,
  # Data type conversion
- datatype=partial(construct_datatype, bundle.config.natural_language, language),
+ datatype=partial(_construct_datatype, bundle),
  t=partial(render_one_statement, bundle),
  )
 

tests/test_problem_statements.py

@@ -206,3 +206,24 @@ def test_long_description():
  actual = process_problem_statement(template, "python")
 
  assert actual == expected
+
+
+def test_language_specific_construct_works():
+ template = r"{{ datatype({'python': 'result'}) }}"
+ actual = process_problem_statement(template, "python")
+ assert actual == "result"
+
+ template = r"{{ datatype({'python': 'result'}).singular }}"
+ actual = process_problem_statement(template, "python")
+ assert actual == "result"
+
+ template = r"{{ datatype({'python': 'result'}).plural }}"
+ actual = process_problem_statement(template, "python")
+ assert actual == "result"
+
+
+def test_language_specific_construct_rejects_missing():
+ template = r"{{ datatype({'python': 'result'}) }}"
+
+ with pytest.raises(AssertionError):
+ process_problem_statement(template, "java")