strictdoc 0.0.59a1__tar.gz → 0.0.59a2__tar.gz

{strictdoc-0.0.59a1 → strictdoc-0.0.59a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: strictdoc
-Version: 0.0.59a1
+Version: 0.0.59a2
 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.59a1 → strictdoc-0.0.59a2}/strictdoc/__init__.py

@@ -1,6 +1,6 @@
 from strictdoc.core.environment import SDocRuntimeEnvironment
 
-__version__ = "0.0.59a1"
+__version__ = "0.0.59a2"
 
 
 environment = SDocRuntimeEnvironment(__file__)

{strictdoc-0.0.59a1 → strictdoc-0.0.59a2}/strictdoc/backend/excel/export/excel_generator.py

@@ -109,13 +109,10 @@ class ExcelGenerator:
                             if len(parent_refs) > 0:
                                 # TODO Allow multiple parent refs
                                 ref = parent_refs[0]
-                                if (
-                                    len(ref.ref_uid)
-                                    > columns[field][MAX_WIDTH_KEY]
-                                ):
-                                    columns[field][MAX_WIDTH_KEY] = len(
-                                        ref.ref_uid
-                                    )
+                                columns[field][MAX_WIDTH_KEY] = max(
+                                    len(ref.ref_uid),
+                                    columns[field][MAX_WIDTH_KEY],
+                                )
                                 if ref.ref_uid in req_uid_rows:
                                     worksheet.write_url(
                                         row,
@@ -171,15 +168,17 @@ class ExcelGenerator:
                                 )
                                 worksheet.write(row, idx, relations_row_value)
                                 value_len = len(relations_row_value)
-                                if value_len > columns[field][MAX_WIDTH_KEY]:
-                                    columns[field][MAX_WIDTH_KEY] = value_len
+                                columns[field][MAX_WIDTH_KEY] = max(
+                                    value_len, columns[field][MAX_WIDTH_KEY]
+                                )
                         elif field_uc in node.ordered_fields_lookup.keys():
                             req_field = node.ordered_fields_lookup[field_uc][0]
                             value: str = req_field.get_text_value()
                             worksheet.write(row, idx, value)
                             value_len = len(value)
-                            if value_len > columns[field][MAX_WIDTH_KEY]:
-                                columns[field][MAX_WIDTH_KEY] = value_len
+                            columns[field][MAX_WIDTH_KEY] = max(
+                                value_len, columns[field][MAX_WIDTH_KEY]
+                            )
                         elif hasattr(node, "special_fields"):
                             if len(node.special_fields):
                                 for special_field in node.special_fields:

{strictdoc-0.0.59a1 → strictdoc-0.0.59a2}/strictdoc/cli/cli_arg_parser.py

@@ -66,24 +66,6 @@ class ImportExcelCommandConfig:
         self.parser = parser
 
 
-class PassthroughCommandConfig:
-    def __init__(
-        self,
-        input_file,
-        output_dir: Optional[str],
-        filter_requirements: Optional[str],
-        filter_sections: Optional[str],
-        free_text_to_text: bool,
-        view: Optional[str],
-    ):
-        self.input_file = input_file
-        self.output_dir: Optional[str] = output_dir
-        self.filter_requirements: Optional[str] = filter_requirements
-        self.filter_sections: Optional[str] = filter_sections
-        self.free_text_to_text: bool = free_text_to_text
-        self.view: Optional[str] = view
-
-
 @auto_described
 class ServerCommandConfig:
     def __init__(
@@ -146,6 +128,8 @@ class ExportCommandConfig:  # pylint: disable=too-many-instance-attributes
         reqif_multiline_is_xhtml: bool,
         reqif_enable_mid: bool,
         view: Optional[str],
+        chromedriver: Optional[str],
+        free_text_to_text: bool,
     ):
         assert isinstance(input_paths, list), f"{input_paths}"
         self.input_paths: List[str] = input_paths
@@ -165,6 +149,8 @@ class ExportCommandConfig:  # pylint: disable=too-many-instance-attributes
         self.reqif_enable_mid: bool = reqif_enable_mid
         self.view: Optional[str] = view
         self.output_html_root: str = os.path.join(output_dir, "html")
+        self.chromedriver: Optional[str] = chromedriver
+        self.free_text_to_text: bool = free_text_to_text
 
     def get_path_to_config(self) -> str:
         # FIXME: The control flow can be improved.
@@ -263,16 +249,6 @@ class SDocArgsParser:
             self.args.command == "manage" and self.args.subcommand == "auto-uid"
         )
 
-    def get_passthrough_config(self) -> PassthroughCommandConfig:
-        return PassthroughCommandConfig(
-            self.args.input_file,
-            self.args.output_dir,
-            filter_requirements=self.args.filter_requirements,
-            filter_sections=self.args.filter_sections,
-            free_text_to_text=self.args.free_text_to_text,
-            view=self.args.view,
-        )
-
     def get_export_config(self) -> ExportCommandConfig:
         project_title: Optional[str] = self.args.project_title
 
@@ -298,6 +274,8 @@ class SDocArgsParser:
             self.args.reqif_multiline_is_xhtml,
             self.args.reqif_enable_mid,
             self.args.view,
+            self.args.chromedriver,
+            self.args.free_text_to_text,
         )
 
     def get_import_config_reqif(self, _) -> ImportReqIFCommandConfig:

{strictdoc-0.0.59a1 → strictdoc-0.0.59a2}/strictdoc/cli/command_parser_builder.py

@@ -15,6 +15,7 @@ EXPORT_FORMATS = [
     "excel",
     "reqif-sdoc",
     "reqifz-sdoc",
+    "sdoc",
     "spdx",
 ]
 EXCEL_PARSERS = ["basic"]
@@ -243,6 +244,21 @@ class CommandParserBuilder:
             type=str,
             help="Choose which view will be exported.",
         )
+        command_parser_export.add_argument(
+            "--chromedriver",
+            type=str,
+            help="Path to pre installed chromedriver for html2pdf. "
+            "If not given, chromedriver is downloaded and saved to "
+            "strictdoc cache.",
+        )
+        command_parser_export.add_argument(
+            "--free-text-to-text",
+            action="store_true",
+            help=(
+                "This option makes all FREETEXT nodes to be converted to the new "
+                "TEXT nodes."
+            ),
+        )
         add_config_argument(command_parser_export)
 
     @staticmethod
@@ -373,13 +389,19 @@ class CommandParserBuilder:
 
     @staticmethod
     def add_passthrough_command(parent_command_parser):
+        # passthrough command is kept for backwards compatibility. It will
+        # internally be handled as export --formats sdoc.
         command_parser_passthrough = parent_command_parser.add_parser(
             "passthrough",
-            help="Read an SDoc file, then output it again. (used for testing)",
+            help="Read an SDoc file, then output it again. Deprecated, use "
+            "strictdoc export --formats sdoc instead.",
             formatter_class=formatter,
         )
         command_parser_passthrough.add_argument(
-            "input_file", type=str, help="Path to the input SDoc file."
+            "input_paths",
+            type=str,
+            nargs="+",
+            help="One or more folders with *.sdoc files",
         )
         command_parser_passthrough.add_argument(
             "--output-dir",
@@ -410,6 +432,63 @@ class CommandParserBuilder:
             help="Choose which view will be exported.",
         )
 
+        # Hidden default values to make deprecated passthrough parser compatible
+        # with SDocArgsParser.get_export_config.
+        command_parser_passthrough.add_argument(
+            "--project-title", const=None, help=argparse.SUPPRESS
+        )
+        command_parser_passthrough.add_argument(
+            "--formats",
+            default=["sdoc"],
+            help=argparse.SUPPRESS,
+        )
+        command_parser_passthrough.add_argument(
+            "--fields",
+            default=None,
+            help=argparse.SUPPRESS,
+        )
+        command_parser_passthrough.add_argument(
+            "--generate-bundle-document",
+            default=False,
+            help=argparse.SUPPRESS,
+        )
+        command_parser_passthrough.add_argument(
+            "--no-parallelization",
+            default=False,
+            help=argparse.SUPPRESS,
+        )
+        command_parser_passthrough.add_argument(
+            "--enable-mathjax",
+            default=False,
+            help=argparse.SUPPRESS,
+        )
+        command_parser_passthrough.add_argument(
+            "--included-documents",
+            default=False,
+            help=argparse.SUPPRESS,
+        )
+        command_parser_passthrough.add_argument(
+            "--reqif-profile",
+            default=None,
+            help=argparse.SUPPRESS,
+        )
+        command_parser_passthrough.add_argument(
+            "--reqif-multiline-is-xhtml",
+            default=False,
+            help=argparse.SUPPRESS,
+        )
+        command_parser_passthrough.add_argument(
+            "--reqif-enable-mid",
+            default=False,
+            help=argparse.SUPPRESS,
+        )
+        command_parser_passthrough.add_argument(
+            "--chromedriver",
+            default=None,
+            help=argparse.SUPPRESS,
+        )
+        add_config_argument(command_parser_passthrough)
+
     @staticmethod
     def add_dump_command(parent_command_parser):
         command_parser_dump_grammar = parent_command_parser.add_parser(

{strictdoc-0.0.59a1 → strictdoc-0.0.59a2}/strictdoc/cli/main.py

@@ -23,7 +23,6 @@ from strictdoc.cli.cli_arg_parser import (
     ImportExcelCommandConfig,
     ImportReqIFCommandConfig,
     ManageAutoUIDCommandConfig,
-    PassthroughCommandConfig,
     create_sdoc_args_parser,
 )
 from strictdoc.commands.about_command import AboutCommand
@@ -33,7 +32,6 @@ from strictdoc.commands.manage_autouid_command import ManageAutoUIDCommand
 from strictdoc.commands.version_command import VersionCommand
 from strictdoc.core.actions.export_action import ExportAction
 from strictdoc.core.actions.import_action import ImportAction
-from strictdoc.core.actions.passthrough_action import PassthroughAction
 from strictdoc.core.project_config import ProjectConfig, ProjectConfigLoader
 from strictdoc.helpers.exception import StrictDocException
 from strictdoc.helpers.parallelizer import Parallelizer
@@ -44,27 +42,13 @@ def _main(parallelizer: Parallelizer) -> None:
     parser = create_sdoc_args_parser()
 
     project_config: ProjectConfig
-    if parser.is_passthrough_command:
-        passthrough_config: PassthroughCommandConfig = (
-            parser.get_passthrough_config()
-        )
-        input_file = passthrough_config.input_file
-        if not os.path.exists(input_file):
-            sys.stdout.flush()
-            message = "error: passthrough command's input path is neither a folder or a file."
-            print(f"{message}: {input_file}")  # noqa: T201
-            sys.exit(1)
-
-        project_config = ProjectConfigLoader.load_from_path_or_get_default(
-            path_to_config=os.getcwd(),
-            environment=environment,
-        )
-        project_config.integrate_passthrough_config(passthrough_config)
-
-        passthrough_action = PassthroughAction()
-        passthrough_action.passthrough(project_config)
 
-    elif parser.is_export_command:
+    if parser.is_passthrough_command or parser.is_export_command:
+        if parser.is_passthrough_command:
+            print(  # noqa: T201
+                "warning: passthrough is deprecated, use strictdoc "
+                "export --formats sdoc instead."
+            )
         export_config: ExportCommandConfig = parser.get_export_config()
         try:
             export_config.validate()
@@ -141,7 +125,7 @@ def _main(parallelizer: Parallelizer) -> None:
             environment=environment,
         )
         # FIXME: This must be improved.
-        project_config.export_input_paths = [manage_config.input_path]
+        project_config.input_paths = [manage_config.input_path]
         # FIXME: This must be improved.
         project_config.autouuid_include_sections = (
             manage_config.include_sections

{strictdoc-0.0.59a1 → strictdoc-0.0.59a2}/strictdoc/commands/diff_command.py

@@ -52,8 +52,8 @@ class DiffCommand:
         project_config_copy_lhs: ProjectConfig = deepcopy(project_config)
         project_config_copy_rhs: ProjectConfig = deepcopy(project_config)
 
-        project_config_copy_lhs.export_input_paths = [lhs_export_input_abs_path]
-        project_config_copy_rhs.export_input_paths = [rhs_export_input_abs_path]
+        project_config_copy_lhs.input_paths = [lhs_export_input_abs_path]
+        project_config_copy_rhs.input_paths = [rhs_export_input_abs_path]
 
         change_container: ChangeContainer = ChangeGenerator.generate(
             lhs_project_config=project_config_copy_lhs,

{strictdoc-0.0.59a1 → strictdoc-0.0.59a2}/strictdoc/core/actions/export_action.py

@@ -8,6 +8,7 @@ from strictdoc.backend.excel.export.excel_generator import ExcelGenerator
 from strictdoc.backend.reqif.reqif_export import ReqIFExport
 from strictdoc.backend.sdoc.errors.document_tree_error import DocumentTreeError
 from strictdoc.backend.sdoc.models.document import SDocDocument
+from strictdoc.backend.sdoc.writer import SDWriter
 from strictdoc.core.project_config import ProjectConfig
 from strictdoc.core.traceability_index import TraceabilityIndex
 from strictdoc.core.traceability_index_builder import TraceabilityIndexBuilder
@@ -18,6 +19,7 @@ from strictdoc.export.html2pdf.html2pdf_generator import HTML2PDFGenerator
 from strictdoc.export.json.json_generator import JSONGenerator
 from strictdoc.export.rst.document_rst_generator import DocumentRSTGenerator
 from strictdoc.export.spdx.spdx_generator import SPDXGenerator
+from strictdoc.helpers.parallelizer import NullParallelizer
 from strictdoc.helpers.timing import timing_decorator
 
 
@@ -94,7 +96,7 @@ class ExportAction:
 
             if "html2pdf" in self.project_config.export_formats:
                 output_html2pdf_root = os.path.join(
-                    self.project_config.export_output_dir, "html2pdf"
+                    self.project_config.output_dir, "html2pdf"
                 )
                 Path(output_html2pdf_root).mkdir(parents=True, exist_ok=True)
                 HTML2PDFGenerator.export_tree(
@@ -115,7 +117,7 @@ class ExportAction:
 
         if "rst" in self.project_config.export_formats:
             output_rst_root = os.path.join(
-                self.project_config.export_output_dir, "rst"
+                self.project_config.output_dir, "rst"
             )
             Path(output_rst_root).mkdir(parents=True, exist_ok=True)
             DocumentRSTGenerator.export_tree(
@@ -123,7 +125,7 @@ class ExportAction:
             )
 
         if "excel" in self.project_config.export_formats:
-            output_excel_root = f"{self.project_config.export_output_dir}/excel"
+            output_excel_root = f"{self.project_config.output_dir}/excel"
             ExcelGenerator.export_tree(
                 self.traceability_index,
                 output_excel_root,
@@ -131,7 +133,7 @@ class ExportAction:
             )
 
         if "reqif-sdoc" in self.project_config.export_formats:
-            output_reqif_root = f"{self.project_config.export_output_dir}/reqif"
+            output_reqif_root = f"{self.project_config.output_dir}/reqif"
             ReqIFExport.export(
                 project_config=self.project_config,
                 traceability_index=self.traceability_index,
@@ -140,7 +142,7 @@ class ExportAction:
             )
 
         if "reqifz-sdoc" in self.project_config.export_formats:
-            output_reqif_root = f"{self.project_config.export_output_dir}/reqif"
+            output_reqif_root = f"{self.project_config.output_dir}/reqif"
             ReqIFExport.export(
                 project_config=self.project_config,
                 traceability_index=self.traceability_index,
@@ -148,9 +150,12 @@ class ExportAction:
                 reqifz=True,
             )
 
+        if "sdoc" in self.project_config.export_formats:
+            self.export_sdoc()
+
         if "spdx" in self.project_config.export_formats:
             output_dot_root = os.path.join(
-                self.project_config.export_output_dir, "spdx"
+                self.project_config.output_dir, "spdx"
             )
             Path(output_dot_root).mkdir(parents=True, exist_ok=True)
             SPDXGenerator().export_tree(
@@ -159,9 +164,61 @@ class ExportAction:
 
         if "json" in self.project_config.export_formats:
             output_json_root = os.path.join(
-                self.project_config.export_output_dir, "json"
+                self.project_config.output_dir, "json"
             )
             Path(output_json_root).mkdir(parents=True, exist_ok=True)
             JSONGenerator().export_tree(
                 self.traceability_index, self.project_config, output_json_root
             )
+
+    def export_sdoc(self):
+        assert self.project_config.input_paths
+        try:
+            traceability_index: TraceabilityIndex = (
+                TraceabilityIndexBuilder.create(
+                    project_config=self.project_config,
+                    parallelizer=NullParallelizer(),
+                )
+            )
+        except DocumentTreeError as exc:
+            print(exc.to_print_message())  # noqa: T201
+            sys.exit(1)
+        else:
+            assert traceability_index.document_tree
+
+        writer = SDWriter(self.project_config)
+
+        output_base_dir = (
+            self.project_config.output_dir
+            if self.project_config.output_dir is not None
+            else os.path.join(os.getcwd(), "output")
+        )
+        output_dir = os.path.join(output_base_dir, "sdoc")
+        for document in traceability_index.document_tree.document_list:
+            assert document.meta
+            assert document.meta.document_filename_base
+            assert document.meta.input_doc_dir_rel_path
+            output, fragments_dict = writer.write_with_fragments(
+                document,
+                convert_free_text_to_text=self.project_config.free_text_to_text,
+            )
+
+            path_to_output_file_dir: str = os.path.join(
+                output_dir, document.meta.input_doc_dir_rel_path.relative_path
+            )
+            Path(path_to_output_file_dir).mkdir(parents=True, exist_ok=True)
+            path_to_output_file = os.path.join(
+                path_to_output_file_dir, document.meta.document_filename_base
+            )
+            path_to_output_file += ".sdoc"
+            with open(path_to_output_file, "w", encoding="utf8") as file:
+                file.write(output)
+
+            for fragment_path_, fragment_content_ in fragments_dict.items():
+                path_to_output_fragment = os.path.join(
+                    path_to_output_file_dir, fragment_path_
+                )
+                with open(
+                    path_to_output_fragment, "w", encoding="utf8"
+                ) as file_:
+                    file_.write(fragment_content_)

{strictdoc-0.0.59a1 → strictdoc-0.0.59a2}/strictdoc/core/document_finder.py

@@ -30,8 +30,8 @@ class DocumentFinder:
     def find_sdoc_content(
         project_config: ProjectConfig, parallelizer: Parallelizer
     ) -> Tuple[DocumentTree, AssetManager]:
-        assert project_config.export_input_paths is not None
-        for paths_to_files_or_doc in project_config.export_input_paths:
+        assert project_config.input_paths is not None
+        for paths_to_files_or_doc in project_config.input_paths:
             if not os.path.exists(paths_to_files_or_doc):
                 sys.stdout.flush()
                 err = (
@@ -99,7 +99,7 @@ class DocumentFinder:
 
         process_document_binding = partial(
             DocumentFinder._process_worker_parse_document,
-            path_to_output_root=project_config.export_output_dir,
+            path_to_output_root=project_config.output_dir,
         )
 
         found_documents = parallelizer.run_parallel(
@@ -187,13 +187,13 @@ class DocumentFinder:
     def _build_file_tree(
         project_config: ProjectConfig,
     ) -> Tuple[List[FileTree], AssetManager]:
-        assert isinstance(project_config.export_input_paths, list)
-        assert len(project_config.export_input_paths) > 0
+        assert isinstance(project_config.input_paths, list)
+        assert len(project_config.input_paths) > 0
 
         root_trees: List[FileTree] = []
         asset_manager = AssetManager()
 
-        for path_to_doc_root_raw in project_config.export_input_paths:
+        for path_to_doc_root_raw in project_config.input_paths:
             if os.path.isfile(path_to_doc_root_raw):
                 path_to_doc_root = path_to_doc_root_raw
                 if not os.path.isabs(path_to_doc_root):
@@ -238,10 +238,10 @@ class DocumentFinder:
                 )
 
             # Finding SDoc files.
-            assert isinstance(project_config.export_output_dir, str)
+            assert isinstance(project_config.output_dir, str)
             file_tree_structure = FileFinder.find_files_with_extensions(
                 root_path=path_to_doc_root,
-                ignored_dirs=[project_config.export_output_dir],
+                ignored_dirs=[project_config.output_dir],
                 extensions=[".sdoc", ".sgra"],
                 include_paths=project_config.include_doc_paths,
                 exclude_paths=project_config.exclude_doc_paths,

{strictdoc-0.0.59a1 → strictdoc-0.0.59a2}/strictdoc/core/finders/source_files_finder.py

@@ -145,11 +145,11 @@ class SourceFilesFinder:
             else doctree_root_abs_path
         )
 
-        assert isinstance(project_config.export_output_dir, str)
+        assert isinstance(project_config.output_dir, str)
 
         file_tree = FileFinder.find_files_with_extensions(
             root_path=doctree_root_abs_path,
-            ignored_dirs=[project_config.export_output_dir],
+            ignored_dirs=[project_config.output_dir],
             extensions=None,
             include_paths=project_config.include_source_paths,
             exclude_paths=project_config.exclude_source_paths,

{strictdoc-0.0.59a1 → strictdoc-0.0.59a2}/strictdoc/core/project_config.py

@@ -13,7 +13,6 @@ from strictdoc.backend.reqif.sdoc_reqif_fields import ReqIFProfile
 from strictdoc.backend.sdoc.constants import SDocMarkup
 from strictdoc.cli.cli_arg_parser import (
     ExportCommandConfig,
-    PassthroughCommandConfig,
     ServerCommandConfig,
 )
 from strictdoc.helpers.auto_described import auto_described
@@ -95,6 +94,7 @@ class ProjectConfig:  # pylint: disable=too-many-instance-attributes
         reqif_enable_mid: bool,
         reqif_import_markup: Optional[str],
         config_last_update: Optional[datetime.datetime],
+        chromedriver: Optional[str],
     ):
         assert isinstance(environment, SDocRuntimeEnvironment)
         if source_root_path is not None:
@@ -116,19 +116,19 @@ class ProjectConfig:  # pylint: disable=too-many-instance-attributes
         self.exclude_source_paths: List[str] = exclude_source_paths
 
         # Settings derived from the command-line parameters.
+
+        # Common settings
+        self.input_paths: Optional[List[str]] = None
+        self.output_dir: str = "output"
+
         # Export action.
-        self.export_input_paths: Optional[List[str]] = None
-        self.export_output_dir: str = "output"
         self.export_output_html_root: Optional[str] = None
         self.export_formats: Optional[List[str]] = None
         self.export_included_documents: bool = False
         self.generate_bundle_document: bool = False
         self.filter_requirements: Optional[str] = None
         self.filter_sections: Optional[str] = None
-
-        self.passthrough_input_path: Optional[str] = None
-        self.passthrough_output_dir: Optional[str] = None
-        self.passthrough_free_text_to_text: bool = False
+        self.free_text_to_text: bool = False
 
         self.excel_export_fields: Optional[List[str]] = None
 
@@ -149,6 +149,7 @@ class ProjectConfig:  # pylint: disable=too-many-instance-attributes
         )
         self.is_running_on_server: bool = False
         self.view: Optional[str] = None
+        self.chromedriver: Optional[str] = chromedriver
 
     @staticmethod
     def default_config(environment: SDocRuntimeEnvironment):
@@ -172,6 +173,7 @@ class ProjectConfig:  # pylint: disable=too-many-instance-attributes
             reqif_enable_mid=False,
             reqif_import_markup=None,
             config_last_update=None,
+            chromedriver=None,
         )
 
     # Some server command settings can override the project config settings.
@@ -184,16 +186,18 @@ class ProjectConfig:  # pylint: disable=too-many-instance-attributes
     def integrate_export_config(self, export_config: ExportCommandConfig):
         if export_config.project_title is not None:
             self.project_title = export_config.project_title
-        self.export_input_paths = export_config.input_paths
-        self.export_output_dir = export_config.output_dir
+        self.input_paths = export_config.input_paths
+        self.output_dir = export_config.output_dir
         self.export_output_html_root = export_config.output_html_root
         self.export_formats = export_config.formats
         self.export_included_documents = export_config.included_documents
         self.generate_bundle_document = export_config.generate_bundle_document
+        self.free_text_to_text = export_config.free_text_to_text
         self.filter_requirements = export_config.filter_requirements
         self.filter_sections = export_config.filter_sections
         self.excel_export_fields = export_config.fields
         self.view = export_config.view
+        self.chromedriver = export_config.chromedriver
         if self.source_root_path is None:
             source_root_path = export_config.input_paths[0]
             if not os.path.abspath(source_root_path):
@@ -218,17 +222,6 @@ class ProjectConfig:  # pylint: disable=too-many-instance-attributes
         if not self.reqif_enable_mid:
             self.reqif_enable_mid = export_config.reqif_enable_mid
 
-    def integrate_passthrough_config(self, config: PassthroughCommandConfig):
-        self.passthrough_input_path = config.input_file
-        self.passthrough_output_dir = config.output_dir
-        self.passthrough_free_text_to_text = config.free_text_to_text
-        self.filter_requirements = config.filter_requirements
-        self.filter_sections = config.filter_sections
-        self.view = config.view
-
-        # FIXME: Traceability Index is coupled with HTML output.
-        self.export_output_html_root = "NOT_RELEVANT"
-
     def is_feature_activated(self, feature: ProjectFeature):
         return feature in self.project_features
 
@@ -368,6 +361,7 @@ class ProjectConfigLoader:
         reqif_multiline_is_xhtml = False
         reqif_enable_mid = False
         reqif_import_markup: Optional[str] = None
+        chromedriver: Optional[str] = None
 
         if "project" in config_dict:
             project_content = config_dict["project"]
@@ -507,6 +501,13 @@ class ProjectConfigLoader:
                     assert relation_tuple is not None
                     traceability_matrix_relation_columns.append(relation_tuple)
 
+            chromedriver = project_content.get("chromedriver", chromedriver)
+            if chromedriver is not None and not os.path.isfile(chromedriver):
+                print(  # noqa: T201
+                    f"warning: strictdoc.toml: chromedriver {chromedriver} "
+                    "not found."
+                )
+
         if "server" in config_dict:
             # FIXME: Introduce at least a basic validation for the host/port.
             server_content = config_dict["server"]
@@ -554,4 +555,5 @@ class ProjectConfigLoader:
             reqif_enable_mid=reqif_enable_mid,
             reqif_import_markup=reqif_import_markup,
             config_last_update=config_last_update,
+            chromedriver=chromedriver,
         )

{strictdoc-0.0.59a1 → strictdoc-0.0.59a2}/strictdoc/core/transforms/create_requirement.py

@@ -106,7 +106,7 @@ class CreateRequirementTransform:
                     parsed_html,
                     rst_error,
                 ) = RstToHtmlFragmentWriter(
-                    path_to_output_dir=self.project_config.export_output_dir,
+                    path_to_output_dir=self.project_config.output_dir,
                     context_document=document,
                 ).write_with_validation(field_.field_value)
                 if parsed_html is None:

{strictdoc-0.0.59a1 → strictdoc-0.0.59a2}/strictdoc/core/transforms/update_requirement.py

@@ -112,7 +112,7 @@ class CreateOrUpdateNodeCommand:
                     parsed_html,
                     rst_error,
                 ) = RstToHtmlFragmentWriter(
-                    path_to_output_dir=self.project_config.export_output_dir,
+                    path_to_output_dir=self.project_config.output_dir,
                     context_document=self.context_document,
                 ).write_with_validation(field_.field_value)
                 if parsed_html is None: