Merge pull request #7 from kraken-tech/strict-mode

Strict mode

Author: seddonym

README.md

@@ -67,15 +67,16 @@ bundle = rustfluent.Bundle(
 
 #### Parameters
 
-| Name        | Type        | Description                                                                                                             |
-|-------------|-------------|-------------------------------------------------------------------------------------------------------------------------|
-| `language`  | `str`       | [Unicode Language Identifier](https://unicode.org/reports/tr35/tr35.html#Unicode_language_identifier) for the language. |
-| `ftl_files` | `list[str]` | Full paths to the FTL files containing the translations. Entries in later files overwrite earlier ones.                 |
+| Name        | Type             | Description                                                                                                                                                              |
+|-------------|------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------|
+| `language`  | `str`            | [Unicode Language Identifier](https://unicode.org/reports/tr35/tr35.html#Unicode_language_identifier) for the language.                                                  |
+| `ftl_files` | `list[str]`      | Full paths to the FTL files containing the translations. Entries in later files overwrite earlier ones.                                                                  |
+| `strict`    | `bool`, optional | In strict mode, a `ParserError` will be raised if there are any errors in the file. In non-strict mode, invalid Fluent messages will be excluded from the Bundle. |
 
 #### Raises
 
 - `FileNotFoundError` if any of the FTL files could not be found.
-- `ValueError` if any of the FTL files contain errors.
+- `rustfluent.ParserError` if any of the FTL files contain errors (strict mode only).
 
 ### `Bundle.get_translation`
 

src/lib.rs

@@ -7,9 +7,14 @@ use pyo3::types::{PyDict, PyList};
 use std::fs;
 use unic_langid::LanguageIdentifier;
 
+use pyo3::create_exception;
+
+create_exception!(rustfluent, PyParserError, pyo3::exceptions::PyException);
+
 #[pymodule]
 fn rustfluent(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_class::<Bundle>()?;
+    m.add("ParserError", m.py().get_type_bound::<PyParserError>())?;
     Ok(())
 }
 
@@ -21,7 +26,8 @@ struct Bundle {
 #[pymethods]
 impl Bundle {
     #[new]
-    fn new(language: &str, ftl_filenames: &'_ Bound<'_, PyList>) -> PyResult<Self> {
+    #[pyo3(signature = (language, ftl_filenames, strict=false))]
+    fn new(language: &str, ftl_filenames: &'_ Bound<'_, PyList>, strict: bool) -> PyResult<Self> {
         let langid: LanguageIdentifier = language.parse().expect("Parsing failed");
         let mut bundle = FluentBundle::new_concurrent(vec![langid]);
 
@@ -32,16 +38,22 @@ impl Bundle {
                 Err(_) => return Err(PyFileNotFoundError::new_err(file_path.to_string())),
             };
 
-            let res = match FluentResource::try_new(contents) {
-                Ok(res) => res,
+            let resource = match FluentResource::try_new(contents) {
+                Ok(resource) => resource,
                 Err(error) => {
-                    return Err(PyValueError::new_err(format!(
-                        "{error:?} - Fluent file contains errors"
-                    )))
+                    if strict {
+                        return Err(PyParserError::new_err(format!(
+                            "Error when parsing {}.",
+                            file_path
+                        )));
+                    } else {
+                        // The first element of the error is the parsed resource, minus any
+                        // invalid messages.
+                        error.0
+                    }
                 }
             };
-
-            bundle.add_resource_overriding(res);
+            bundle.add_resource_overriding(resource);
         }
 
         Ok(Self { bundle })

src/rustfluent.pyi

@@ -1,3 +1,3 @@
 class Bundle:
-    def __init__(self, language: str, ftl_filenames: list[str]) -> None: ...
+    def __init__(self, language: str, ftl_filenames: list[str], strict: bool = False) -> None: ...
     def get_translation(self, identifier: str, variables: dict[str, str] | None = None) -> str: ...

tests/data/errors.ftl

@@ -1 +1,3 @@
-bobbins
+invalid-message
+
+valid-message = I'm valid.

tests/test_python_interface.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python
-
 import pathlib
+import re
 
 import pytest
 
@@ -66,6 +66,19 @@ def test_file_not_found():
         fluent.Bundle("fr", [str(data_dir / "none.ftl")])
 
 
-def test_file_has_errors():
-    with pytest.raises(ValueError):
-        fluent.Bundle("fr", [str(data_dir / "errors.ftl")])
+@pytest.mark.parametrize("pass_strict_argument_explicitly", (True, False))
+def test_parses_other_parts_of_file_that_contains_errors_in_non_strict_mode(
+    pass_strict_argument_explicitly,
+):
+    kwargs = dict(strict=False) if pass_strict_argument_explicitly else {}
+
+    bundle = fluent.Bundle("fr", [str(data_dir / "errors.ftl")], **kwargs)
+    translation = bundle.get_translation("valid-message")
+
+    assert translation == "I'm valid."
+
+
+def test_raises_parser_error_on_file_that_contains_errors_in_strict_mode():
+    filename = str(data_dir / "errors.ftl")
+    with pytest.raises(fluent.ParserError, match=re.escape(f"Error when parsing {filename}.")):
+        fluent.Bundle("fr", [filename], strict=True)