@owenlamont/ryl 0.4.1 → 0.4.2

package/tests/config_quoted_strings.rs

@@ -1,195 +0,0 @@
-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

@@ -1,147 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,110 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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"));
-}