ucn 3.0.0

package/test/fixtures/rust/main.rs

@@ -0,0 +1,253 @@
+//! Main Rust test fixtures.
+//! Tests structs, traits, enums, and async functions.
+
+mod service;
+mod utils;
+
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex};
+
+/// Status enum representing task states.
+#[derive(Debug, Clone, PartialEq)]
+pub enum Status {
+    Pending,
+    Active,
+    Completed,
+    Failed,
+}
+
+/// Task struct representing a task entity.
+#[derive(Debug, Clone)]
+pub struct Task {
+    pub id: String,
+    pub name: String,
+    pub status: Status,
+    pub priority: i32,
+    pub metadata: HashMap<String, String>,
+}
+
+impl Task {
+    /// Create a new task.
+    pub fn new(id: String, name: String) -> Self {
+        Task {
+            id,
+            name,
+            status: Status::Pending,
+            priority: 1,
+            metadata: HashMap::new(),
+        }
+    }
+
+    /// Set the task priority.
+    pub fn with_priority(mut self, priority: i32) -> Self {
+        self.priority = priority;
+        self
+    }
+
+    /// Set the task status.
+    pub fn with_status(mut self, status: Status) -> Self {
+        self.status = status;
+        self
+    }
+
+    /// Check if the task is complete.
+    pub fn is_complete(&self) -> bool {
+        self.status == Status::Completed
+    }
+}
+
+/// Trait for entities with an ID.
+pub trait Entity {
+    fn get_id(&self) -> &str;
+}
+
+impl Entity for Task {
+    fn get_id(&self) -> &str {
+        &self.id
+    }
+}
+
+/// Task manager that manages a collection of tasks.
+pub struct TaskManager {
+    tasks: Arc<Mutex<Vec<Task>>>,
+}
+
+impl TaskManager {
+    /// Create a new task manager.
+    pub fn new() -> Self {
+        TaskManager {
+            tasks: Arc::new(Mutex::new(Vec::new())),
+        }
+    }
+
+    /// Add a task to the manager.
+    pub fn add_task(&self, task: Task) -> Result<(), String> {
+        validate_task(&task)?;
+        let mut tasks = self.tasks.lock().unwrap();
+        tasks.push(task);
+        Ok(())
+    }
+
+    /// Get a task by ID.
+    pub fn get_task(&self, id: &str) -> Option<Task> {
+        let tasks = self.tasks.lock().unwrap();
+        tasks.iter().find(|t| t.id == id).cloned()
+    }
+
+    /// Get all tasks, optionally filtered.
+    pub fn get_tasks<F>(&self, filter: Option<F>) -> Vec<Task>
+    where
+        F: Fn(&Task) -> bool,
+    {
+        let tasks = self.tasks.lock().unwrap();
+        match filter {
+            Some(f) => tasks.iter().filter(|t| f(t)).cloned().collect(),
+            None => tasks.clone(),
+        }
+    }
+
+    /// Update a task by ID.
+    pub fn update_task(&self, id: &str, name: Option<String>, status: Option<Status>) -> Option<Task> {
+        let mut tasks = self.tasks.lock().unwrap();
+        for task in tasks.iter_mut() {
+            if task.id == id {
+                if let Some(n) = name {
+                    task.name = n;
+                }
+                if let Some(s) = status {
+                    task.status = s;
+                }
+                return Some(task.clone());
+            }
+        }
+        None
+    }
+
+    /// Delete a task by ID.
+    pub fn delete_task(&self, id: &str) -> bool {
+        let mut tasks = self.tasks.lock().unwrap();
+        let len_before = tasks.len();
+        tasks.retain(|t| t.id != id);
+        tasks.len() < len_before
+    }
+
+    /// Get the count of tasks.
+    pub fn count(&self) -> usize {
+        let tasks = self.tasks.lock().unwrap();
+        tasks.len()
+    }
+}
+
+impl Default for TaskManager {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// Validate a task.
+pub fn validate_task(task: &Task) -> Result<(), String> {
+    if task.id.is_empty() {
+        return Err("Task ID is required".to_string());
+    }
+    if task.name.is_empty() {
+        return Err("Task name is required".to_string());
+    }
+    Ok(())
+}
+
+/// Create a new task with a generated ID.
+pub fn create_task(name: &str, priority: i32) -> Task {
+    let id = generate_id();
+    Task::new(id, name.to_string()).with_priority(priority)
+}
+
+/// Generate a unique ID.
+fn generate_id() -> String {
+    use std::sync::atomic::{AtomicUsize, Ordering};
+    static COUNTER: AtomicUsize = AtomicUsize::new(0);
+    let id = COUNTER.fetch_add(1, Ordering::SeqCst);
+    format!("task-{}", id)
+}
+
+/// Filter tasks by status.
+pub fn filter_by_status(tasks: &[Task], status: Status) -> Vec<Task> {
+    tasks.iter().filter(|t| t.status == status).cloned().collect()
+}
+
+/// Filter tasks by minimum priority.
+pub fn filter_by_priority(tasks: &[Task], min_priority: i32) -> Vec<Task> {
+    tasks.iter().filter(|t| t.priority >= min_priority).cloned().collect()
+}
+
+/// Task processor for processing tasks.
+pub struct TaskProcessor {
+    manager: Arc<TaskManager>,
+}
+
+impl TaskProcessor {
+    /// Create a new task processor.
+    pub fn new(manager: Arc<TaskManager>) -> Self {
+        TaskProcessor { manager }
+    }
+
+    /// Process all tasks.
+    pub fn process_all(&self) -> Vec<HashMap<String, String>> {
+        let tasks = self.manager.get_tasks::<fn(&Task) -> bool>(None);
+        tasks.iter().map(|t| self.process_task(t)).collect()
+    }
+
+    /// Process only pending tasks.
+    pub fn process_pending(&self) -> Vec<HashMap<String, String>> {
+        let tasks = self.manager.get_tasks(Some(|t: &Task| t.status == Status::Pending));
+        tasks.iter().map(|t| self.process_task(t)).collect()
+    }
+
+    /// Process a single task.
+    fn process_task(&self, task: &Task) -> HashMap<String, String> {
+        format_task(task)
+    }
+}
+
+/// Format a task as a map.
+pub fn format_task(task: &Task) -> HashMap<String, String> {
+    let mut map = HashMap::new();
+    map.insert("id".to_string(), task.id.clone());
+    map.insert("name".to_string(), task.name.clone());
+    map.insert("status".to_string(), format!("{:?}", task.status));
+    map.insert("priority".to_string(), task.priority.to_string());
+    map
+}
+
+/// Unused function for deadcode detection.
+#[allow(dead_code)]
+fn unused_function() -> &'static str {
+    "never used"
+}
+
+fn main() {
+    let manager = TaskManager::new();
+    let task = create_task("Test Task", 1);
+    manager.add_task(task).unwrap();
+    println!("Created {} tasks", manager.count());
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_create_task() {
+        let task = create_task("Test", 1);
+        assert!(!task.id.is_empty());
+        assert_eq!(task.name, "Test");
+        assert_eq!(task.priority, 1);
+    }
+
+    #[test]
+    fn test_task_manager() {
+        let manager = TaskManager::new();
+        let task = create_task("Test", 1);
+        manager.add_task(task).unwrap();
+        assert_eq!(manager.count(), 1);
+    }
+}

package/test/fixtures/rust/service.rs

@@ -0,0 +1,210 @@
+//! Service module for data operations.
+
+use std::collections::HashMap;
+use std::sync::{Arc, Mutex};
+use std::time::{Duration, Instant};
+
+/// Configuration for services.
+#[derive(Debug, Clone)]
+pub struct Config {
+    pub api_url: String,
+    pub timeout: Duration,
+    pub retries: u32,
+    pub debug: bool,
+}
+
+impl Default for Config {
+    fn default() -> Self {
+        Config {
+            api_url: "https://api.example.com".to_string(),
+            timeout: Duration::from_secs(5),
+            retries: 3,
+            debug: false,
+        }
+    }
+}
+
+/// Repository trait for data access.
+pub trait Repository<T> {
+    fn save(&self, entity: T) -> Result<(), String>;
+    fn find(&self, id: &str) -> Option<T>;
+    fn find_all(&self) -> Vec<T>;
+    fn delete(&self, id: &str) -> bool;
+}
+
+/// Generic data service.
+pub struct DataService<T: Clone> {
+    config: Config,
+    storage: Arc<Mutex<HashMap<String, T>>>,
+}
+
+impl<T: Clone> DataService<T> {
+    /// Create a new data service.
+    pub fn new(config: Config) -> Self {
+        DataService {
+            config,
+            storage: Arc::new(Mutex::new(HashMap::new())),
+        }
+    }
+
+    /// Create with default config.
+    pub fn with_defaults() -> Self {
+        Self::new(Config::default())
+    }
+
+    /// Get the config.
+    pub fn config(&self) -> &Config {
+        &self.config
+    }
+
+    /// Clear all stored entities.
+    pub fn clear(&self) {
+        let mut storage = self.storage.lock().unwrap();
+        storage.clear();
+    }
+}
+
+/// Cache entry with timestamp.
+struct CacheEntry<T> {
+    value: T,
+    timestamp: Instant,
+}
+
+/// Caching service with TTL.
+pub struct CacheService<T: Clone> {
+    ttl: Duration,
+    cache: Arc<Mutex<HashMap<String, CacheEntry<T>>>>,
+}
+
+impl<T: Clone> CacheService<T> {
+    /// Create a new cache service.
+    pub fn new(ttl: Duration) -> Self {
+        CacheService {
+            ttl,
+            cache: Arc::new(Mutex::new(HashMap::new())),
+        }
+    }
+
+    /// Get a value from cache.
+    pub fn get(&self, key: &str) -> Option<T> {
+        let cache = self.cache.lock().unwrap();
+        if let Some(entry) = cache.get(key) {
+            if entry.timestamp.elapsed() < self.ttl {
+                return Some(entry.value.clone());
+            }
+        }
+        None
+    }
+
+    /// Set a value in cache.
+    pub fn set(&self, key: String, value: T) {
+        let mut cache = self.cache.lock().unwrap();
+        cache.insert(key, CacheEntry {
+            value,
+            timestamp: Instant::now(),
+        });
+    }
+
+    /// Delete a value from cache.
+    pub fn delete(&self, key: &str) -> bool {
+        let mut cache = self.cache.lock().unwrap();
+        cache.remove(key).is_some()
+    }
+
+    /// Clear all values from cache.
+    pub fn clear(&self) {
+        let mut cache = self.cache.lock().unwrap();
+        cache.clear();
+    }
+
+    /// Remove expired entries.
+    pub fn cleanup_expired(&self) -> usize {
+        let mut cache = self.cache.lock().unwrap();
+        let expired: Vec<String> = cache
+            .iter()
+            .filter(|(_, entry)| entry.timestamp.elapsed() >= self.ttl)
+            .map(|(key, _)| key.clone())
+            .collect();
+        let count = expired.len();
+        for key in expired {
+            cache.remove(&key);
+        }
+        count
+    }
+}
+
+/// HTTP client for API requests.
+pub struct ApiClient {
+    config: Config,
+}
+
+impl ApiClient {
+    /// Create a new API client.
+    pub fn new(config: Config) -> Self {
+        ApiClient { config }
+    }
+
+    /// Make a GET request.
+    pub async fn get(&self, path: &str) -> Result<HashMap<String, String>, String> {
+        let url = self.build_url(path);
+        self.request("GET", &url, None).await
+    }
+
+    /// Make a POST request.
+    pub async fn post(&self, path: &str, data: HashMap<String, String>) -> Result<HashMap<String, String>, String> {
+        let url = self.build_url(path);
+        self.request("POST", &url, Some(data)).await
+    }
+
+    /// Make a DELETE request.
+    pub async fn delete(&self, path: &str) -> Result<HashMap<String, String>, String> {
+        let url = self.build_url(path);
+        self.request("DELETE", &url, None).await
+    }
+
+    /// Build the full URL.
+    fn build_url(&self, path: &str) -> String {
+        if path.starts_with("http") {
+            path.to_string()
+        } else {
+            format!("{}{}", self.config.api_url, path)
+        }
+    }
+
+    /// Make an HTTP request.
+    async fn request(
+        &self,
+        method: &str,
+        url: &str,
+        _data: Option<HashMap<String, String>>,
+    ) -> Result<HashMap<String, String>, String> {
+        // Simulated request
+        let mut result = HashMap::new();
+        result.insert("status".to_string(), "200".to_string());
+        result.insert("method".to_string(), method.to_string());
+        result.insert("url".to_string(), url.to_string());
+        Ok(result)
+    }
+}
+
+/// Create a data service with defaults.
+pub fn create_service<T: Clone>() -> DataService<T> {
+    DataService::with_defaults()
+}
+
+/// Create an API client with defaults.
+pub fn create_api_client() -> ApiClient {
+    ApiClient::new(Config::default())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_cache_service() {
+        let cache: CacheService<String> = CacheService::new(Duration::from_secs(60));
+        cache.set("key".to_string(), "value".to_string());
+        assert_eq!(cache.get("key"), Some("value".to_string()));
+    }
+}

package/test/fixtures/rust/utils.rs

@@ -0,0 +1,154 @@
+//! Utility functions for data manipulation.
+
+use std::collections::HashMap;
+
+/// Format data as a string.
+pub fn format_data<T: std::fmt::Debug>(data: &T) -> String {
+    format!("{:?}", data)
+}
+
+/// Validate that a value is not empty.
+pub fn validate_not_empty(value: &str) -> Result<(), String> {
+    if value.is_empty() {
+        Err("Value cannot be empty".to_string())
+    } else {
+        Ok(())
+    }
+}
+
+/// Deep merge two HashMaps.
+pub fn deep_merge(
+    base: HashMap<String, String>,
+    updates: HashMap<String, String>,
+) -> HashMap<String, String> {
+    let mut result = base;
+    for (key, value) in updates {
+        result.insert(key, value);
+    }
+    result
+}
+
+/// Flatten a nested vector.
+pub fn flatten<T: Clone>(nested: Vec<Vec<T>>) -> Vec<T> {
+    nested.into_iter().flatten().collect()
+}
+
+/// Split a vector into chunks.
+pub fn chunk<T: Clone>(items: Vec<T>, size: usize) -> Vec<Vec<T>> {
+    items.chunks(size).map(|c| c.to_vec()).collect()
+}
+
+/// Safely get a value from a HashMap.
+pub fn safe_get<'a>(map: &'a HashMap<String, String>, key: &str) -> Option<&'a String> {
+    map.get(key)
+}
+
+/// Transform all keys in a HashMap.
+pub fn transform_keys<F>(map: HashMap<String, String>, transformer: F) -> HashMap<String, String>
+where
+    F: Fn(&str) -> String,
+{
+    map.into_iter().map(|(k, v)| (transformer(&k), v)).collect()
+}
+
+/// Convert snake_case to camelCase.
+pub fn snake_to_camel(name: &str) -> String {
+    let mut result = String::new();
+    let mut capitalize_next = false;
+
+    for ch in name.chars() {
+        if ch == '_' {
+            capitalize_next = true;
+        } else if capitalize_next {
+            result.push(ch.to_ascii_uppercase());
+            capitalize_next = false;
+        } else {
+            result.push(ch);
+        }
+    }
+
+    result
+}
+
+/// Convert camelCase to snake_case.
+pub fn camel_to_snake(name: &str) -> String {
+    let mut result = String::new();
+
+    for ch in name.chars() {
+        if ch.is_uppercase() {
+            if !result.is_empty() {
+                result.push('_');
+            }
+            result.push(ch.to_ascii_lowercase());
+        } else {
+            result.push(ch);
+        }
+    }
+
+    result
+}
+
+/// Data transformer struct.
+pub struct DataTransformer {
+    transformations: Vec<Box<dyn Fn(String) -> String>>,
+}
+
+impl DataTransformer {
+    /// Create a new data transformer.
+    pub fn new() -> Self {
+        DataTransformer {
+            transformations: Vec::new(),
+        }
+    }
+
+    /// Add a transformation.
+    pub fn add_transformation<F>(&mut self, f: F) -> &mut Self
+    where
+        F: Fn(String) -> String + 'static,
+    {
+        self.transformations.push(Box::new(f));
+        self
+    }
+
+    /// Apply all transformations.
+    pub fn transform(&self, data: String) -> String {
+        let mut result = data;
+        for f in &self.transformations {
+            result = f(result);
+        }
+        result
+    }
+
+    /// Clear all transformations.
+    pub fn clear(&mut self) {
+        self.transformations.clear();
+    }
+}
+
+impl Default for DataTransformer {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// Process and format data.
+pub fn process_and_format<T: std::fmt::Debug>(data: &T) -> String {
+    format_data(data)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_snake_to_camel() {
+        assert_eq!(snake_to_camel("hello_world"), "helloWorld");
+        assert_eq!(snake_to_camel("some_long_name"), "someLongName");
+    }
+
+    #[test]
+    fn test_camel_to_snake() {
+        assert_eq!(camel_to_snake("helloWorld"), "hello_world");
+        assert_eq!(camel_to_snake("someLongName"), "some_long_name");
+    }
+}