strictdoc 0.0.44a7__tar.gz → 0.0.44a9__tar.gz

{strictdoc-0.0.44a7 → strictdoc-0.0.44a9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strictdoc
-Version: 0.0.44a7
+Version: 0.0.44a9
 Summary: StrictDoc is open-source software for technical documentation and requirements management.
 Project-URL: Changelog, https://github.com/strictdoc-project/strictdoc/blob/main/CHANGELOG.md
 Project-URL: Homepage, https://strictdoc.readthedocs.io/en/stable/

{strictdoc-0.0.44a7 → strictdoc-0.0.44a9}/strictdoc/__init__.py

@@ -1,6 +1,6 @@
 from strictdoc.core.environment import SDocRuntimeEnvironment
 
-__version__ = "0.0.44a7"
+__version__ = "0.0.44a9"
 
 
 environment = SDocRuntimeEnvironment(__file__)

{strictdoc-0.0.44a7 → strictdoc-0.0.44a9}/strictdoc/backend/sdoc/models/document_grammar.py

@@ -54,17 +54,17 @@ class DocumentGrammar:
 
         registered_elements: Set[str] = set()
         elements_by_type: Dict[str, GrammarElement] = {}
-        fields_by_type: Dict[str, Set[str]] = defaultdict(set)
+        fields_by_type: Dict[str, List[str]] = defaultdict(list)
 
         for element in elements:
             registered_elements.add(element.tag)
             elements_by_type[element.tag] = element
             for element_field in element.fields:
-                fields_by_type[element.tag].add(element_field.title)
+                fields_by_type[element.tag].append(element_field.title)
 
         self.registered_elements: Set[str] = registered_elements
         self.elements_by_type: Dict[str, GrammarElement] = elements_by_type
-        self.fields_order_by_type: Dict[str, Set[str]] = fields_by_type
+        self.fields_order_by_type: Dict[str, List[str]] = fields_by_type
 
         self.is_default = False
 

{strictdoc-0.0.44a7 → strictdoc-0.0.44a9}/strictdoc/backend/sdoc/validations/requirement.py

@@ -33,9 +33,9 @@ def multi_choice_regex_match(value):
 def validate_requirement(
     requirement: Requirement, document_grammar: DocumentGrammar
 ):
-    registered_fields: Set[str] = document_grammar.fields_order_by_type[
-        requirement.requirement_type
-    ]
+    registered_fields: Set[str] = set(
+        document_grammar.fields_order_by_type[requirement.requirement_type]
+    )
     for field_name in requirement.ordered_fields_lookup:
         if field_name not in registered_fields:
             raise StrictDocSemanticError.unregistered_field(

{strictdoc-0.0.44a7 → strictdoc-0.0.44a9}/strictdoc/cli/cli_arg_parser.py

@@ -5,6 +5,10 @@ from strictdoc.cli.command_parser_builder import CommandParserBuilder
 from strictdoc.helpers.auto_described import auto_described
 
 
+class CLIValidationError(Exception):
+    pass
+
+
 class ImportReqIFCommandConfig:
     def __init__(self, input_path: str, output_path: str, profile):
         self.input_path: str = input_path
@@ -13,8 +17,29 @@ class ImportReqIFCommandConfig:
 
 
 class ManageAutoUIDCommandConfig:
-    def __init__(self, *, input_path: str):
+    def __init__(self, *, input_path: str, config_path: Optional[str]):
         self.input_path: str = input_path
+        self._config_path: Optional[str] = config_path
+
+    def get_path_to_config(self) -> Optional[str]:
+        path_to_input_dir = self.input_path
+        if os.path.isfile(path_to_input_dir):
+            path_to_input_dir = os.path.dirname(path_to_input_dir)
+        path_to_config = (
+            self._config_path
+            if self._config_path is not None
+            else path_to_input_dir
+        )
+        return path_to_config
+
+    def validate(self):
+        if self._config_path is not None and not os.path.exists(
+            self._config_path
+        ):
+            raise CLIValidationError(
+                "Provided path to a configuration file does not exist: "
+                f"{self._config_path}"
+            )
 
 
 class ImportExcelCommandConfig:
@@ -37,16 +62,40 @@ class ServerCommandConfig:
         *,
         input_path: str,
         output_path: Optional[str],
+        config_path: Optional[str],
         reload: bool,
         port: Optional[int],
     ):
-        assert os.path.exists(input_path)
-        abs_input_path = os.path.abspath(input_path)
-        self.input_path: str = abs_input_path
+        self._input_path: str = input_path
         self.output_path: Optional[str] = output_path
+        self._config_path: Optional[str] = config_path
         self.reload: bool = reload
         self.port: Optional[int] = port
 
+    def get_full_input_path(self):
+        return os.path.abspath(self._input_path)
+
+    def get_path_to_config(self):
+        return (
+            self._config_path
+            if self._config_path is not None
+            else self._input_path
+        )
+
+    def validate(self):
+        if not os.path.exists(self._input_path):
+            raise CLIValidationError(
+                f"Provided input path does not exist: {self._input_path}"
+            )
+
+        if self._config_path is not None and not os.path.exists(
+            self._config_path
+        ):
+            raise CLIValidationError(
+                "Provided path to a configuration file does not exist: "
+                f"{self._config_path}"
+            )
+
 
 @auto_described
 class ExportCommandConfig:  # pylint: disable=too-many-instance-attributes
@@ -54,6 +103,7 @@ class ExportCommandConfig:  # pylint: disable=too-many-instance-attributes
         self,
         input_paths,
         output_dir: str,
+        config_path: Optional[str],
         project_title: Optional[str],
         formats,
         fields,
@@ -65,6 +115,7 @@ class ExportCommandConfig:  # pylint: disable=too-many-instance-attributes
         assert isinstance(input_paths, list), f"{input_paths}"
         self.input_paths: List[str] = input_paths
         self.output_dir: str = output_dir
+        self._config_path: Optional[str] = config_path
         self.project_title: Optional[str] = project_title
         self.formats = formats
         self.fields = fields
@@ -76,6 +127,30 @@ class ExportCommandConfig:  # pylint: disable=too-many-instance-attributes
         )
         self.output_html_root: str = os.path.join(output_dir, "html")
 
+    def get_path_to_config(self) -> Optional[str]:
+        path_to_input_dir = self.input_paths[0]
+        if os.path.isfile(path_to_input_dir):
+            path_to_input_dir = os.path.dirname(path_to_input_dir)
+        path_to_config = (
+            self._config_path
+            if self._config_path is not None
+            else path_to_input_dir
+        )
+        return path_to_config
+
+    def validate(self):
+        for input_path_ in self.input_paths:
+            if not os.path.exists(input_path_):
+                raise CLIValidationError(
+                    f"Provided input path does not exist: {input_path_}"
+                )
+        if self._config_path is not None:
+            if not os.path.exists(self._config_path):
+                raise CLIValidationError(
+                    "Provided path to a configuration file does not exist: "
+                    f"{self._config_path}"
+                )
+
 
 class DumpGrammarCommandConfig:
     def __init__(self, output_file):
@@ -144,6 +219,7 @@ class SDocArgsParser:
         return ExportCommandConfig(
             self.args.input_paths,
             output_dir,
+            self.args.config,
             project_title,
             self.args.formats,
             self.args.fields,
@@ -159,7 +235,10 @@ class SDocArgsParser:
         )
 
     def get_manage_autouid_config(self) -> ManageAutoUIDCommandConfig:
-        return ManageAutoUIDCommandConfig(input_path=self.args.input_path)
+        return ManageAutoUIDCommandConfig(
+            input_path=self.args.input_path,
+            config_path=self.args.config,
+        )
 
     def get_import_config_excel(self, _) -> ImportExcelCommandConfig:
         return ImportExcelCommandConfig(
@@ -170,6 +249,7 @@ class SDocArgsParser:
         return ServerCommandConfig(
             input_path=self.args.input_path,
             output_path=self.args.output_path,
+            config_path=self.args.config,
             reload=self.args.reload,
             port=self.args.port,
         )

{strictdoc-0.0.44a7 → strictdoc-0.0.44a9}/strictdoc/cli/command_parser_builder.py

@@ -41,6 +41,14 @@ def _parse_fields(fields):
     return fields_array
 
 
+def add_config_argument(parser):
+    parser.add_argument(
+        "--config",
+        type=str,
+        help="Path to the StrictDoc TOML config file.",
+    )
+
+
 class SDocArgumentParser(argparse.ArgumentParser):
     def error(self, message: str):
         self.print_usage(sys.stderr)
@@ -68,6 +76,7 @@ class CommandParserBuilder:
                 """
             ),
         )
+
         command_subparsers = main_parser.add_subparsers(
             title="command", dest="command"
         )
@@ -75,9 +84,9 @@ class CommandParserBuilder:
 
         self.add_about_command(command_subparsers)
         self.add_export_command(command_subparsers)
-        self.add_import_command(command_subparsers)
         self.add_server_command(command_subparsers)
         self.add_manage_command(command_subparsers)
+        self.add_import_command(command_subparsers)
         self.add_version_command(command_subparsers)
         self.add_passthrough_command(command_subparsers)
         self.add_dump_command(command_subparsers)
@@ -86,7 +95,7 @@ class CommandParserBuilder:
 
     @staticmethod
     def add_about_command(parent_command_parser):
-        _ = parent_command_parser.add_parser(
+        parent_command_parser.add_parser(
             "about",
             help="About StrictDoc.",
             description="About StrictDoc.",
@@ -158,6 +167,7 @@ class CommandParserBuilder:
                 "enables traceability between requirements and files."
             ),
         )
+        add_config_argument(command_parser_export)
 
     @staticmethod
     def add_import_command(parent_command_parser):
@@ -255,6 +265,7 @@ class CommandParserBuilder:
             "--no-reload", dest="reload", action="store_false"
         )
         command_parser_server.add_argument("--port", type=IntRange(1024, 65000))
+        add_config_argument(command_parser_server)
 
     @staticmethod
     def add_version_command(parent_command_parser):
@@ -274,7 +285,6 @@ class CommandParserBuilder:
         command_parser_passthrough.add_argument(
             "input_file", type=str, help="Path to the input SDoc file"
         )
-
         command_parser_passthrough.add_argument(
             "--output-file", type=str, help="Path to the output SDoc file"
         )
@@ -303,7 +313,7 @@ class CommandParserBuilder:
         )
         manage_command_subparsers.required = True
 
-        command_parser_import_reqif = manage_command_subparsers.add_parser(
+        command_parser_auto_uid = manage_command_subparsers.add_parser(
             "auto-uid",
             help="Generates missing requirements UIDs automatically.",
             description=(
@@ -315,8 +325,9 @@ class CommandParserBuilder:
             formatter_class=formatter,
         )
 
-        command_parser_import_reqif.add_argument(
+        command_parser_auto_uid.add_argument(
             "input_path",
             type=str,
             help="Path to the project tree.",
         )
+        add_config_argument(command_parser_auto_uid)

{strictdoc-0.0.44a7 → strictdoc-0.0.44a9}/strictdoc/cli/main.py

@@ -16,6 +16,7 @@ sys.path.append(strictdoc_root_path)
 
 from strictdoc import environment
 from strictdoc.cli.cli_arg_parser import (
+    CLIValidationError,
     DumpGrammarCommandConfig,
     ExportCommandConfig,
     ImportExcelCommandConfig,
@@ -61,9 +62,14 @@ def _main(parallelizer):
 
     elif parser.is_export_command:
         config: ExportCommandConfig = parser.get_export_config()
+        try:
+            config.validate()
+        except CLIValidationError as exception_:
+            print(f"error: {exception_.args[0]}")  # noqa: T201
+            sys.exit(1)
         project_config: ProjectConfig = (
             ProjectConfigLoader.load_from_path_or_get_default(
-                path_to_config_dir=config.input_paths[0],
+                path_to_config=config.get_path_to_config(),
                 environment=environment,
             )
         )
@@ -84,9 +90,14 @@ def _main(parallelizer):
 
     elif parser.is_server_command:
         server_config = parser.get_server_config()
+        try:
+            server_config.validate()
+        except CLIValidationError as exception_:
+            print(f"error: {exception_.args[0]}")  # noqa: T201
+            sys.exit(1)
         project_config: ProjectConfig = (
             ProjectConfigLoader.load_from_path_or_get_default(
-                path_to_config_dir=server_config.input_path,
+                path_to_config=server_config.get_path_to_config(),
                 environment=environment,
             )
         )
@@ -110,12 +121,18 @@ def _main(parallelizer):
 
     elif parser.is_manage_autouid_command:
         config: ManageAutoUIDCommandConfig = parser.get_manage_autouid_config()
+        try:
+            config.validate()
+        except CLIValidationError as exception_:
+            print(f"error: {exception_.args[0]}")  # noqa: T201
+            sys.exit(1)
         project_config: ProjectConfig = (
             ProjectConfigLoader.load_from_path_or_get_default(
-                path_to_config_dir=config.input_path,
+                path_to_config=config.get_path_to_config(),
                 environment=environment,
             )
         )
+        # FIXME: This must be improved.
         project_config.export_input_paths = [config.input_path]
         ManageAutoUIDCommand.execute(
             project_config=project_config, parallelizer=parallelizer

{strictdoc-0.0.44a7 → strictdoc-0.0.44a9}/strictdoc/core/project_config.py

@@ -215,13 +215,13 @@ class ProjectConfigLoader:
     @staticmethod
     def load_from_path_or_get_default(
         *,
-        path_to_config_dir: str,
+        path_to_config: str,
         environment: SDocRuntimeEnvironment,
     ) -> ProjectConfig:
-        if not os.path.exists(path_to_config_dir):
+        if not os.path.exists(path_to_config):
             return ProjectConfig.default_config(environment=environment)
-
-        path_to_config = os.path.join(path_to_config_dir, "strictdoc.toml")
+        if os.path.isdir(path_to_config):
+            path_to_config = os.path.join(path_to_config, "strictdoc.toml")
         if not os.path.isfile(path_to_config):
             return ProjectConfig.default_config(environment=environment)
 

{strictdoc-0.0.44a7 → strictdoc-0.0.44a9}/strictdoc/export/html/form_objects/document_grammar_form_object.py

@@ -1,6 +1,5 @@
 import re
-from collections import defaultdict
-from typing import Dict, List
+from typing import List, Optional, Set
 
 from starlette.datastructures import FormData
 
@@ -34,10 +33,12 @@ class GrammarFormField:
     def __init__(
         self,
         field_name: str,
+        previous_name: Optional[str],
         field_required: bool,
         reserved: bool,
     ):
         self.field_name: str = field_name
+        self.previous_name: Optional[str] = previous_name
         self.field_required: bool = field_required
         self.reserved: bool = reserved
 
@@ -46,6 +47,7 @@ class GrammarFormField:
         reserved = is_reserved_field(grammar_field.title)
         return GrammarFormField(
             field_name=grammar_field.title,
+            previous_name=grammar_field.title,
             field_required=grammar_field.required,
             reserved=reserved,
         )
@@ -72,29 +74,27 @@ class DocumentGrammarFormObject(ErrorObject):
     def create_from_request(
         *, document_mid: str, request_form_data: FormData
     ) -> "DocumentGrammarFormObject":
-        grammar_fields: Dict[str, List[str]] = defaultdict(list)
-
         # For now, the convention is that the new fields have empty
         # brackets, e.g., ('document_grammar[]', 'CUSTOM_FIELD_1').
         # The existing fields are:
         # ('document_grammar[RATIONALE]', 'RATIONALE')  # noqa: ERA001
         # This structure will be changed when not just field names, but also
         # their options will be passed to this parser.
+        form_object_fields = []
+
         for field_name, field_value in request_form_data.multi_items():
-            assert isinstance(field_value, str)
             result = re.search(r"^document_grammar\[(.*)]$", field_name)
             if result is not None:
-                grammar_fields[field_value].append(field_value)
-
-        form_object_fields = []
-        for grammar_field_name in grammar_fields:
-            grammar_field = grammar_fields[grammar_field_name]
-            form_object_field = GrammarFormField(
-                field_name=grammar_field[0],
-                field_required=False,
-                reserved=is_reserved_field(grammar_field_name),
-            )
-            form_object_fields.append(form_object_field)
+                previous_name: Optional[str] = None
+                if len(result.group(1)) > 0:
+                    previous_name = result.group(1)
+                form_object_field = GrammarFormField(
+                    field_name=field_value,
+                    previous_name=previous_name,
+                    field_required=False,
+                    reserved=is_reserved_field(field_value),
+                )
+                form_object_fields.append(form_object_field)
 
         form_object = DocumentGrammarFormObject(
             document_mid=document_mid,
@@ -124,12 +124,22 @@ class DocumentGrammarFormObject(ErrorObject):
         )
 
     def validate(self) -> bool:
+        fields_so_far: Set[str] = set()
         for field in self.fields:
             if len(field.field_name) == 0:
                 self.add_error(
                     field.field_name,
                     f"Grammar field {field.field_name} must not be empty.",
                 )
+                continue
+
+            if field.field_name in fields_so_far:
+                self.add_error(
+                    field.field_name,
+                    f"Grammar field {field.field_name} is not unique.",
+                )
+            else:
+                fields_so_far.add(field.field_name)
         return len(self.errors) == 0
 
     def convert_to_document_grammar(self) -> DocumentGrammar:

{strictdoc-0.0.44a7 → strictdoc-0.0.44a9}/strictdoc/server/main.py

@@ -35,12 +35,13 @@ if __name__ == "__main__":
     server_command_config = ServerCommandConfig(
         input_path=input_path,
         output_path=output_path,
+        config_path=None,
         reload=args.reload,
         port=5111,
     )
     project_config: ProjectConfig = (
         ProjectConfigLoader.load_from_path_or_get_default(
-            path_to_config_dir=input_path, environment=environment
+            path_to_config=input_path, environment=environment
         )
     )
     run_strictdoc_server(