@owenlamont/ryl 0.4.1

package/tests/config_quoted_strings.rs

@@ -0,0 +1,195 @@
+use ryl::config::{RuleLevel, YamlLintConfig};
+use ryl::rules::quoted_strings;
+
+#[test]
+fn error_when_quote_type_invalid() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  quoted-strings:\n    quote-type: bad\n",
+    )
+    .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: option \"quote-type\" of \"quoted-strings\" should be in ('any', 'single', 'double')"
+    );
+}
+
+#[test]
+fn error_when_quote_type_not_string() {
+    let err =
+        YamlLintConfig::from_yaml_str("rules:\n  quoted-strings:\n    quote-type: 1\n")
+            .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: option \"quote-type\" of \"quoted-strings\" should be in ('any', 'single', 'double')"
+    );
+}
+
+#[test]
+fn error_when_required_invalid() {
+    let err =
+        YamlLintConfig::from_yaml_str("rules:\n  quoted-strings:\n    required: 3\n")
+            .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: option \"required\" of \"quoted-strings\" should be in (True, False, 'only-when-needed')"
+    );
+}
+
+#[test]
+fn error_when_extra_required_not_sequence() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  quoted-strings:\n    extra-required: foo\n",
+    )
+    .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: option \"extra-required\" of \"quoted-strings\" should only contain values in [<class 'str'>]"
+    );
+}
+
+#[test]
+fn error_when_extra_required_contains_non_string() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  quoted-strings:\n    extra-required: [1]\n",
+    )
+    .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: option \"extra-required\" of \"quoted-strings\" should only contain values in [<class 'str'>]"
+    );
+}
+
+#[test]
+fn error_when_extra_allowed_contains_non_string() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  quoted-strings:\n    extra-allowed: [true]\n",
+    )
+    .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: option \"extra-allowed\" of \"quoted-strings\" should only contain values in [<class 'str'>]"
+    );
+}
+
+#[test]
+fn error_when_allow_quoted_quotes_not_bool() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  quoted-strings:\n    allow-quoted-quotes: 1\n",
+    )
+    .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: option \"allow-quoted-quotes\" of \"quoted-strings\" should be bool"
+    );
+}
+
+#[test]
+fn error_when_check_keys_not_bool() {
+    let err =
+        YamlLintConfig::from_yaml_str("rules:\n  quoted-strings:\n    check-keys: 2\n")
+            .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: option \"check-keys\" of \"quoted-strings\" should be bool"
+    );
+}
+
+#[test]
+fn error_when_required_true_and_extra_required() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  quoted-strings:\n    extra-required: ['^http']\n",
+    )
+    .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: quoted-strings: cannot use both \"required: true\" and \"extra-required\""
+    );
+}
+
+#[test]
+fn error_when_required_true_and_extra_allowed() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  quoted-strings:\n    extra-allowed: ['^http']\n",
+    )
+    .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: quoted-strings: cannot use both \"required: true\" and \"extra-allowed\""
+    );
+}
+
+#[test]
+fn error_when_required_false_and_extra_allowed() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  quoted-strings:\n    required: false\n    extra-allowed: ['^http']\n",
+    )
+    .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: quoted-strings: cannot use both \"required: false\" and \"extra-allowed\""
+    );
+}
+
+#[test]
+fn error_when_extra_required_regex_invalid() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  quoted-strings:\n    required: false\n    extra-required: ['[']\n",
+    )
+    .unwrap_err();
+    assert!(
+        err.starts_with(
+            "invalid config: regex \"[\" in option \"extra-required\" of \"quoted-strings\" is invalid:"
+        ),
+        "unexpected message: {err}"
+    );
+}
+
+#[test]
+fn allows_level_option_to_pass_validation() {
+    let cfg = YamlLintConfig::from_yaml_str(
+        "rules:\n  quoted-strings:\n    level: warning\n",
+    )
+    .expect("config with level should be accepted");
+    assert_eq!(cfg.rule_level("quoted-strings"), Some(RuleLevel::Warning));
+}
+
+#[test]
+fn error_when_rule_ignore_contains_non_string_pattern() {
+    let err =
+        YamlLintConfig::from_yaml_str("rules:\n  quoted-strings:\n    ignore: [1]\n")
+            .unwrap_err();
+    assert_eq!(err, "invalid config: ignore should contain file patterns");
+}
+
+#[test]
+fn error_when_unknown_quoted_strings_option() {
+    let err = YamlLintConfig::from_yaml_str(
+        "rules:\n  quoted-strings:\n    unknown: value\n",
+    )
+    .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: unknown option \"unknown\" for rule \"quoted-strings\""
+    );
+}
+
+#[test]
+fn error_when_option_key_not_string() {
+    let err = YamlLintConfig::from_yaml_str("rules:\n  quoted-strings:\n    1: true\n")
+        .unwrap_err();
+    assert_eq!(
+        err,
+        "invalid config: unknown option \"1\" for rule \"quoted-strings\""
+    );
+}
+
+#[test]
+fn resolve_required_true_sets_mode() {
+    let cfg = YamlLintConfig::from_yaml_str(
+        "rules:\n  quoted-strings:\n    required: true\n",
+    )
+    .expect("config parses");
+    let resolved = quoted_strings::Config::resolve(&cfg);
+    let hits = quoted_strings::check("foo: bar\n", &resolved);
+    assert_eq!(hits.len(), 1);
+}

package/tests/config_rule_level.rs

@@ -0,0 +1,147 @@
+use ryl::config::{Overrides, RuleLevel, YamlLintConfig, discover_config};
+
+#[test]
+fn rule_level_returns_none_for_disable() {
+    let cfg = r#"
+rules:
+  new-line-at-end-of-file: disable
+"#;
+    let context = discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some(cfg.into()),
+        },
+    )
+    .expect("config");
+    assert!(
+        context
+            .config
+            .rule_level("new-line-at-end-of-file")
+            .is_none()
+    );
+}
+
+#[test]
+fn rule_level_parses_warning_mapping() {
+    let cfg = r#"
+rules:
+  new-line-at-end-of-file:
+    level: warning
+"#;
+    let context = discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some(cfg.into()),
+        },
+    )
+    .expect("config");
+    assert_eq!(
+        context
+            .config
+            .rule_level("new-line-at-end-of-file")
+            .expect("level"),
+        RuleLevel::Warning
+    );
+}
+
+#[test]
+fn rule_level_defaults_to_error_for_enable() {
+    let cfg = r#"
+rules:
+  new-line-at-end-of-file: enable
+"#;
+    let context = discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some(cfg.into()),
+        },
+    )
+    .expect("config");
+    assert_eq!(
+        context
+            .config
+            .rule_level("new-line-at-end-of-file")
+            .expect("level"),
+        RuleLevel::Error
+    );
+}
+
+#[test]
+fn rule_level_defaults_to_error_when_mapping_missing_level() {
+    let cfg = r#"
+rules:
+  new-line-at-end-of-file: {}
+"#;
+    let context = discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some(cfg.into()),
+        },
+    )
+    .expect("config");
+    assert_eq!(
+        context
+            .config
+            .rule_level("new-line-at-end-of-file")
+            .expect("level"),
+        RuleLevel::Error
+    );
+}
+
+#[test]
+fn invalid_level_not_string_errors() {
+    let cfg = r#"
+rules:
+  new-line-at-end-of-file:
+    level: [1]
+"#;
+    let err = YamlLintConfig::from_yaml_str(cfg).expect_err("invalid");
+    assert!(
+        err.contains("level should be \"error\" or \"warning\""),
+        "unexpected error message: {err}"
+    );
+}
+
+#[test]
+fn invalid_level_value_errors() {
+    let cfg = r#"
+rules:
+  new-line-at-end-of-file:
+    level: invalid
+"#;
+    let err = YamlLintConfig::from_yaml_str(cfg).expect_err("invalid");
+    assert!(
+        err.contains("level should be \"error\" or \"warning\""),
+        "unexpected error message: {err}"
+    );
+}
+
+#[test]
+fn invalid_rule_value_type_errors() {
+    let cfg = r#"
+rules:
+  new-line-at-end-of-file: 42
+"#;
+    let err = YamlLintConfig::from_yaml_str(cfg).expect_err("invalid");
+    assert!(
+        err.contains("should be 'enable', 'disable', or a mapping"),
+        "unexpected error message: {err}"
+    );
+}
+
+#[test]
+fn invalid_rule_value_string_errors() {
+    let cfg = r#"
+rules:
+  new-line-at-end-of-file: other
+"#;
+    let err = YamlLintConfig::from_yaml_str(cfg).expect_err("invalid");
+    assert!(
+        err.contains("should be 'enable', 'disable', or a mapping"),
+        "unexpected error message: {err}"
+    );
+}

package/tests/config_rules_non_string_keys.rs

@@ -0,0 +1,23 @@
+use ryl::config::{Overrides, discover_config};
+
+#[test]
+fn rules_with_non_string_key_are_skipped() {
+    // Include a non-string key in the rules map to exercise the `continue` path.
+    // YAML: a sequence used as a key plus a normal string key.
+    let cfg = r#"
+rules:
+  ? [1, 2]
+  : { level: warning }
+  anchors: { forbid-undeclared-aliases: false }
+"#;
+    let ctx = discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some(cfg.into()),
+        },
+    )
+    .expect("parse");
+    // The valid rule should still be present; the non-string key entry is ignored.
+    assert!(ctx.config.rule_names().iter().any(|r| r == "anchors"));
+}

package/tests/config_scalar_overrides.rs

@@ -0,0 +1,27 @@
+use ryl::config::{Overrides, discover_config};
+
+#[test]
+fn scalar_ignore_and_yaml_files_string_are_parsed() {
+    let cfg = "ignore: 'docs/**'\nyaml-files: ['.yamllint.yml']\n";
+    let ctx = discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some(cfg.into()),
+        },
+    )
+    .expect("parse");
+    let base = ctx.base_dir.clone();
+    assert!(
+        ctx.config
+            .is_file_ignored(&base.join("docs/x.yaml"), &ctx.base_dir)
+    );
+    assert!(
+        ctx.config
+            .is_yaml_candidate(&base.join(".yamllint.yml"), &ctx.base_dir)
+    );
+}
+
+// Note: saphyr treats some malformed YAML as BadValue without returning an error,
+// so invalid inline config data may not cause a hard parse error. We avoid
+// asserting on exit codes for inline parse failures here.

package/tests/config_to_toml.rs

@@ -0,0 +1,110 @@
+use std::fs;
+
+use ryl::config::{Overrides, discover_config};
+use tempfile::tempdir;
+
+#[test]
+fn to_toml_includes_ignore_and_locale_and_rules() {
+    let ctx = discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some(
+                "ignore: ['vendor/**']\nlocale: en_US.UTF-8\nrules: { document-start: disable }\n"
+                    .to_string(),
+            ),
+        },
+    )
+    .unwrap();
+    let toml = ctx.config.to_toml_string().unwrap();
+    assert!(toml.contains("ignore = ["));
+    assert!(toml.contains("locale = \"en_US.UTF-8\""));
+    assert!(toml.contains("document-start = \"disable\""));
+}
+
+#[test]
+fn to_toml_includes_ignore_from_file_when_present() {
+    let td = tempdir().unwrap();
+    fs::write(td.path().join(".ignore-list"), "build/**\n").unwrap();
+    fs::write(
+        td.path().join(".yamllint"),
+        "ignore-from-file: .ignore-list\nrules: {}\n",
+    )
+    .unwrap();
+    let ctx = discover_config(
+        &[],
+        &Overrides {
+            config_file: Some(td.path().join(".yamllint")),
+            config_data: None,
+        },
+    )
+    .unwrap();
+    let toml = ctx.config.to_toml_string().unwrap();
+    assert!(toml.contains("ignore-from-file = ["));
+}
+
+#[test]
+fn to_toml_errors_on_null_values() {
+    let ctx = discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some("rules: { custom-rule: { opt: ~ } }\n".to_string()),
+        },
+    )
+    .unwrap();
+    let err = ctx.config.to_toml_string().unwrap_err();
+    assert!(err.contains("cannot convert null values to TOML"));
+}
+
+#[test]
+fn to_toml_converts_scalar_sequence_and_mapping_values() {
+    let ctx = discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some(
+                "rules:\n  custom-rule:\n    flag: true\n    count: 3\n    ratio: 1.5\n    list: [1, false]\n    nested: { child: 1 }\n"
+                    .to_string(),
+            ),
+        },
+    )
+    .unwrap();
+    let toml = ctx.config.to_toml_string().unwrap();
+    assert!(toml.contains("flag = true"));
+    assert!(toml.contains("count = 3"));
+    assert!(toml.contains("ratio = 1.5"));
+    assert!(toml.contains("list = ["));
+    assert!(toml.contains("false"));
+    assert!(toml.contains("[rules.custom-rule.nested]"));
+}
+
+#[test]
+fn to_toml_errors_on_non_string_mapping_keys() {
+    let ctx = discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some("rules:\n  custom-rule:\n    1: x\n".to_string()),
+        },
+    )
+    .unwrap();
+    let err = ctx.config.to_toml_string().unwrap_err();
+    assert!(err.contains("cannot convert non-string TOML key"));
+}
+
+#[test]
+fn to_toml_errors_on_tagged_values() {
+    let ctx = discover_config(
+        &[],
+        &Overrides {
+            config_file: None,
+            config_data: Some(
+                "rules:\n  custom-rule:\n    tagged: !demo value\n".to_string(),
+            ),
+        },
+    )
+    .unwrap();
+    let err = ctx.config.to_toml_string().unwrap_err();
+    assert!(err.contains("cannot convert this YAML node to TOML"));
+}

package/tests/config_toml_coverage.rs

@@ -0,0 +1,80 @@
+use std::fs;
+
+use ryl::config::{Overrides, discover_config, discover_per_file};
+use tempfile::tempdir;
+
+#[test]
+fn discover_config_uses_project_toml_and_parses_float_values() {
+    let td = tempdir().unwrap();
+    let root = td.path();
+    fs::write(
+        root.join(".ryl.toml"),
+        "flag = true\nratio = 1.25\nstamp = 1979-05-27T07:32:00Z\n[rules]\nanchors = 'disable'\n",
+    )
+    .unwrap();
+    let file = root.join("file.yaml");
+    fs::write(&file, "a: 1\n").unwrap();
+
+    let ctx = discover_config(&[file], &Overrides::default()).expect("project TOML");
+    assert_eq!(
+        ctx.source.as_deref(),
+        Some(root.join(".ryl.toml").as_path())
+    );
+}
+
+#[test]
+fn discover_config_skips_pyproject_without_tool_ryl_in_project_search() {
+    let td = tempdir().unwrap();
+    let root = td.path();
+    fs::write(
+        root.join("pyproject.toml"),
+        "[project]\nname = 'demo'\nversion = '0.1.0'\n",
+    )
+    .unwrap();
+    fs::write(root.join(".yamllint"), "locale: en_US.UTF-8\nrules: {}\n").unwrap();
+    let file = root.join("file.yaml");
+    fs::write(&file, "a: 1\n").unwrap();
+
+    let ctx = discover_config(&[file], &Overrides::default()).expect("yaml fallback");
+    assert_eq!(
+        ctx.source.as_deref(),
+        Some(root.join(".yamllint").as_path())
+    );
+}
+
+#[test]
+fn discover_per_file_uses_project_toml() {
+    let td = tempdir().unwrap();
+    let root = td.path();
+    fs::write(root.join(".ryl.toml"), "[rules]\nanchors = 'disable'\n").unwrap();
+    let file = root.join("file.yaml");
+    fs::write(&file, "a: 1\n").unwrap();
+
+    let ctx = discover_per_file(&file).expect("per-file project TOML");
+    assert_eq!(
+        ctx.source.as_deref(),
+        Some(root.join(".ryl.toml").as_path())
+    );
+}
+
+#[test]
+fn explicit_pyproject_config_file_with_tool_ryl_loads() {
+    let td = tempdir().unwrap();
+    let root = td.path();
+    let pyproject = root.join("pyproject.toml");
+    fs::write(
+        &pyproject,
+        "[project]\nname = 'demo'\nversion = '0.1.0'\n[tool.ryl]\nlocale = 'it_IT.UTF-8'\n",
+    )
+    .unwrap();
+
+    let ctx = discover_config(
+        &[],
+        &Overrides {
+            config_file: Some(pyproject),
+            config_data: None,
+        },
+    )
+    .expect("explicit pyproject [tool.ryl]");
+    assert_eq!(ctx.config.locale(), Some("it_IT.UTF-8"));
+}