pmat 3.15.0

impl NamingStyle {
    #[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
    /// Matches.
    pub fn matches(&self, name: &str) -> bool {
        match self {
            NamingStyle::SnakeCase => {
                name.chars().all(|c| c.is_lowercase() || c == '_' || c.is_numeric())
            }
            NamingStyle::CamelCase => {
                !name.is_empty() && name.chars().next().expect("checked is_empty").is_lowercase()
                    && !name.contains('_') && !name.contains('-')
            }
            NamingStyle::PascalCase => {
                !name.is_empty() && name.chars().next().expect("checked is_empty").is_uppercase()
                    && !name.contains('_') && !name.contains('-')
            }
            NamingStyle::ScreamingSnakeCase => {
                name.chars().all(|c| c.is_uppercase() || c == '_' || c.is_numeric())
            }
            NamingStyle::KebabCase => {
                name.chars().all(|c| c.is_lowercase() || c == '-' || c.is_numeric())
            }
        }
    }
}

impl LanguageRules {
    #[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
    /// Rust rules.
    pub fn rust_rules() -> Self {
        LanguageRules {
            language: Language::Rust,
            function_style: NamingStyle::SnakeCase,
            type_style: NamingStyle::PascalCase,
            constant_style: NamingStyle::ScreamingSnakeCase,
            variable_style: NamingStyle::SnakeCase,
        }
    }

    #[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
    /// Python rules.
    pub fn python_rules() -> Self {
        LanguageRules {
            language: Language::Python,
            function_style: NamingStyle::SnakeCase,
            type_style: NamingStyle::PascalCase,
            constant_style: NamingStyle::ScreamingSnakeCase,
            variable_style: NamingStyle::SnakeCase,
        }
    }

    #[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
    /// Javascript rules.
    pub fn javascript_rules() -> Self {
        LanguageRules {
            language: Language::JavaScript,
            function_style: NamingStyle::CamelCase,
            type_style: NamingStyle::PascalCase,
            constant_style: NamingStyle::ScreamingSnakeCase,
            variable_style: NamingStyle::CamelCase,
        }
    }

    #[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
    /// Typescript rules.
    pub fn typescript_rules() -> Self {
        LanguageRules {
            language: Language::TypeScript,
            function_style: NamingStyle::CamelCase,
            type_style: NamingStyle::PascalCase,
            constant_style: NamingStyle::ScreamingSnakeCase,
            variable_style: NamingStyle::CamelCase,
        }
    }

    #[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
    /// Go rules.
    pub fn go_rules() -> Self {
        LanguageRules {
            language: Language::Go,
            function_style: NamingStyle::PascalCase,
            type_style: NamingStyle::PascalCase,
            constant_style: NamingStyle::PascalCase,
            variable_style: NamingStyle::CamelCase,
        }
    }

    #[provable_contracts_macros::contract("pmat-core.yaml", equation = "check_compliance")]
    /// Lua rules.
    pub fn lua_rules() -> Self {
        LanguageRules {
            language: Language::Lua,
            function_style: NamingStyle::SnakeCase,
            type_style: NamingStyle::PascalCase,
            constant_style: NamingStyle::ScreamingSnakeCase,
            variable_style: NamingStyle::SnakeCase,
        }
    }
}

#[cfg_attr(coverage_nightly, coverage(off))]
#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_language_from_extension() {
        assert_eq!(Language::from_extension(Path::new("test.rs")), Language::Rust);
        assert_eq!(Language::from_extension(Path::new("test.py")), Language::Python);
        assert_eq!(Language::from_extension(Path::new("test.js")), Language::JavaScript);
        assert_eq!(Language::from_extension(Path::new("test.ts")), Language::TypeScript);
        assert_eq!(Language::from_extension(Path::new("test.go")), Language::Go);
        assert_eq!(Language::from_extension(Path::new("test.java")), Language::Java);
        assert_eq!(Language::from_extension(Path::new("test.c")), Language::C);
        assert_eq!(Language::from_extension(Path::new("test.cpp")), Language::Cpp);
        assert_eq!(Language::from_extension(Path::new("test.unknown")), Language::Unknown);
    }

    #[test]
    fn test_naming_style_matches() {
        assert!(NamingStyle::SnakeCase.matches("snake_case"));
        assert!(NamingStyle::SnakeCase.matches("my_variable_123"));
        assert!(!NamingStyle::SnakeCase.matches("camelCase"));

        assert!(NamingStyle::CamelCase.matches("camelCase"));
        assert!(NamingStyle::CamelCase.matches("myVariable123"));
        assert!(!NamingStyle::CamelCase.matches("PascalCase"));
        assert!(!NamingStyle::CamelCase.matches("snake_case"));

        assert!(NamingStyle::PascalCase.matches("PascalCase"));
        assert!(NamingStyle::PascalCase.matches("MyClass123"));
        assert!(!NamingStyle::PascalCase.matches("camelCase"));
        assert!(!NamingStyle::PascalCase.matches("snake_case"));

        assert!(NamingStyle::ScreamingSnakeCase.matches("SCREAMING_SNAKE"));
        assert!(NamingStyle::ScreamingSnakeCase.matches("MAX_VALUE_123"));
        assert!(!NamingStyle::ScreamingSnakeCase.matches("snake_case"));

        assert!(NamingStyle::KebabCase.matches("kebab-case"));
        assert!(NamingStyle::KebabCase.matches("my-component-123"));
        assert!(!NamingStyle::KebabCase.matches("snake_case"));
    }
}
#[cfg_attr(coverage_nightly, coverage(off))]
#[cfg(test)]
mod property_tests {
    use proptest::prelude::*;

    proptest! {
        #[test]
        fn basic_property_stability(_input in ".*") {
            // Basic property test for coverage
            prop_assert!(true);
        }

        #[test]
        fn module_consistency_check(_x in 0u32..1000) {
            // Module consistency verification
            prop_assert!(_x < 1001);
        }
    }
}