ucn 3.0.0

package/test/fixtures/javascript/utils.js

@@ -0,0 +1,67 @@
+/**
+ * Utility functions for data manipulation.
+ */
+
+/**
+ * Helper function that processes input.
+ * @param {any} input - The input to process
+ * @returns {any} The processed output
+ */
+function helper(input) {
+  return formatData(input);
+}
+
+/**
+ * Format data for output.
+ */
+function formatData(data) {
+  if (Array.isArray(data)) {
+    return data.map(item => formatItem(item));
+  }
+  return formatItem(data);
+}
+
+/**
+ * Format a single item.
+ */
+function formatItem(item) {
+  return {
+    ...item,
+    formatted: true
+  };
+}
+
+/**
+ * Utility function for string operations.
+ */
+const utilFunc = (str) => {
+  return str.trim().toLowerCase();
+};
+
+/**
+ * Deep clone an object.
+ */
+function deepClone(obj) {
+  return JSON.parse(JSON.stringify(obj));
+}
+
+/**
+ * Merge multiple objects.
+ */
+function mergeObjects(...objects) {
+  return objects.reduce((acc, obj) => ({ ...acc, ...obj }), {});
+}
+
+// Unused function (for deadcode detection)
+function unusedHelper() {
+  return 'never called';
+}
+
+module.exports = {
+  helper,
+  formatData,
+  formatItem,
+  utilFunc,
+  deepClone,
+  mergeObjects
+};

package/test/fixtures/python/main.py

@@ -0,0 +1,198 @@
+"""
+Main Python test fixtures.
+Tests classes, decorators, type hints, and async functions.
+"""
+
+from typing import List, Optional, Dict, Any, Callable, TypeVar, Generic
+from dataclasses import dataclass, field
+from enum import Enum
+import asyncio
+
+from .utils import format_data, validate_input, deep_merge
+from .service import DataService, ServiceConfig
+
+
+class Status(Enum):
+    """Task status enumeration."""
+    PENDING = "pending"
+    ACTIVE = "active"
+    COMPLETED = "completed"
+    FAILED = "failed"
+
+
+@dataclass
+class Task:
+    """Task data class."""
+    id: str
+    name: str
+    status: Status = Status.PENDING
+    priority: int = 1
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+
+T = TypeVar('T', bound=Task)
+
+
+class TaskManager(Generic[T]):
+    """Generic task manager class."""
+
+    def __init__(self, config: Optional[ServiceConfig] = None):
+        """Initialize the task manager."""
+        self.config = config or ServiceConfig()
+        self.tasks: List[T] = []
+        self.service = DataService(self.config)
+
+    def add_task(self, task: T) -> None:
+        """Add a task to the manager."""
+        validated = validate_input(task)
+        self.tasks.append(validated)
+
+    def get_task(self, task_id: str) -> Optional[T]:
+        """Get a task by ID."""
+        for task in self.tasks:
+            if task.id == task_id:
+                return task
+        return None
+
+    def get_tasks(self, filter_fn: Optional[Callable[[T], bool]] = None) -> List[T]:
+        """Get all tasks, optionally filtered."""
+        if filter_fn:
+            return [t for t in self.tasks if filter_fn(t)]
+        return self.tasks.copy()
+
+    def update_task(self, task_id: str, **updates) -> Optional[T]:
+        """Update a task by ID."""
+        task = self.get_task(task_id)
+        if task:
+            for key, value in updates.items():
+                if hasattr(task, key):
+                    setattr(task, key, value)
+            return task
+        return None
+
+    def delete_task(self, task_id: str) -> bool:
+        """Delete a task by ID."""
+        task = self.get_task(task_id)
+        if task:
+            self.tasks.remove(task)
+            return True
+        return False
+
+    async def sync_tasks(self) -> int:
+        """Sync tasks with the service."""
+        count = 0
+        for task in self.tasks:
+            await self.service.save(task)
+            count += 1
+        return count
+
+
+def create_task(name: str, priority: int = 1) -> Task:
+    """Factory function to create a task."""
+    import uuid
+    return Task(
+        id=str(uuid.uuid4()),
+        name=name,
+        priority=priority
+    )
+
+
+def filter_by_status(tasks: List[Task], status: Status) -> List[Task]:
+    """Filter tasks by status."""
+    return [t for t in tasks if t.status == status]
+
+
+def filter_by_priority(tasks: List[Task], min_priority: int) -> List[Task]:
+    """Filter tasks by minimum priority."""
+    return [t for t in tasks if t.priority >= min_priority]
+
+
+async def process_tasks_async(tasks: List[Task]) -> List[Dict[str, Any]]:
+    """Process tasks asynchronously."""
+    results = []
+    for task in tasks:
+        result = await process_single_task(task)
+        results.append(result)
+    return results
+
+
+async def process_single_task(task: Task) -> Dict[str, Any]:
+    """Process a single task."""
+    await asyncio.sleep(0.01)  # Simulate async work
+    return format_data(task)
+
+
+def with_logging(func: Callable) -> Callable:
+    """Decorator that adds logging."""
+    def wrapper(*args, **kwargs):
+        print(f"Calling {func.__name__}")
+        result = func(*args, **kwargs)
+        print(f"Finished {func.__name__}")
+        return result
+    return wrapper
+
+
+def with_retry(retries: int = 3):
+    """Decorator factory for retry logic."""
+    def decorator(func: Callable) -> Callable:
+        def wrapper(*args, **kwargs):
+            last_error = None
+            for i in range(retries):
+                try:
+                    return func(*args, **kwargs)
+                except Exception as e:
+                    last_error = e
+            raise last_error
+        return wrapper
+    return decorator
+
+
+@with_logging
+def logged_function(x: int) -> int:
+    """A function with logging decorator."""
+    return x * 2
+
+
+class TaskProcessor:
+    """Process tasks with various strategies."""
+
+    def __init__(self, manager: TaskManager):
+        self.manager = manager
+
+    def process_all(self) -> List[Dict[str, Any]]:
+        """Process all tasks."""
+        tasks = self.manager.get_tasks()
+        return [self._process(t) for t in tasks]
+
+    def process_pending(self) -> List[Dict[str, Any]]:
+        """Process only pending tasks."""
+        tasks = self.manager.get_tasks(
+            lambda t: t.status == Status.PENDING
+        )
+        return [self._process(t) for t in tasks]
+
+    def _process(self, task: Task) -> Dict[str, Any]:
+        """Internal processing method."""
+        data = format_data(task)
+        return deep_merge(data, {"processed": True})
+
+
+# Unused function for deadcode detection
+def unused_function():
+    """This function is never called."""
+    return "never used"
+
+
+__all__ = [
+    'Status',
+    'Task',
+    'TaskManager',
+    'TaskProcessor',
+    'create_task',
+    'filter_by_status',
+    'filter_by_priority',
+    'process_tasks_async',
+    'with_logging',
+    'with_retry',
+    'logged_function',
+]

package/test/fixtures/python/pyproject.toml

@@ -0,0 +1,3 @@
+[project]
+name = "python-fixtures"
+version = "1.0.0"

package/test/fixtures/python/service.py

@@ -0,0 +1,166 @@
+"""
+Service layer for data operations.
+"""
+
+from typing import Any, Dict, List, Optional, TypeVar, Generic
+from dataclasses import dataclass
+import asyncio
+
+from .utils import format_data, validate_input
+
+
+@dataclass
+class ServiceConfig:
+    """Configuration for services."""
+    api_url: str = "https://api.example.com"
+    timeout: int = 5000
+    retries: int = 3
+    debug: bool = False
+
+
+T = TypeVar('T')
+
+
+class DataService(Generic[T]):
+    """Generic data service."""
+
+    def __init__(self, config: Optional[ServiceConfig] = None):
+        self.config = config or ServiceConfig()
+        self._storage: Dict[str, T] = {}
+
+    async def save(self, entity: T) -> None:
+        """Save an entity."""
+        validate_input(entity)
+        entity_id = self._get_id(entity)
+        self._storage[entity_id] = entity
+
+    async def find(self, entity_id: str) -> Optional[T]:
+        """Find an entity by ID."""
+        return self._storage.get(entity_id)
+
+    async def find_all(self) -> List[T]:
+        """Find all entities."""
+        return list(self._storage.values())
+
+    async def delete(self, entity_id: str) -> bool:
+        """Delete an entity."""
+        if entity_id in self._storage:
+            del self._storage[entity_id]
+            return True
+        return False
+
+    def _get_id(self, entity: T) -> str:
+        """Get the ID of an entity."""
+        if hasattr(entity, 'id'):
+            return str(entity.id)
+        raise ValueError("Entity must have an 'id' attribute")
+
+    def clear(self) -> None:
+        """Clear all stored entities."""
+        self._storage.clear()
+
+
+class CacheService:
+    """Caching service."""
+
+    def __init__(self, ttl: int = 300):
+        self.ttl = ttl
+        self._cache: Dict[str, Any] = {}
+        self._timestamps: Dict[str, float] = {}
+
+    def get(self, key: str) -> Optional[Any]:
+        """Get a value from cache."""
+        if key in self._cache:
+            return self._cache[key]
+        return None
+
+    def set(self, key: str, value: Any) -> None:
+        """Set a value in cache."""
+        import time
+        self._cache[key] = value
+        self._timestamps[key] = time.time()
+
+    def delete(self, key: str) -> bool:
+        """Delete a value from cache."""
+        if key in self._cache:
+            del self._cache[key]
+            del self._timestamps[key]
+            return True
+        return False
+
+    def clear(self) -> None:
+        """Clear the cache."""
+        self._cache.clear()
+        self._timestamps.clear()
+
+    def cleanup_expired(self) -> int:
+        """Remove expired entries."""
+        import time
+        now = time.time()
+        expired = [
+            key for key, ts in self._timestamps.items()
+            if now - ts > self.ttl
+        ]
+        for key in expired:
+            self.delete(key)
+        return len(expired)
+
+
+class ApiClient:
+    """HTTP API client."""
+
+    def __init__(self, config: ServiceConfig):
+        self.config = config
+        self.base_url = config.api_url
+
+    async def get(self, path: str) -> Dict[str, Any]:
+        """Make a GET request."""
+        url = self._build_url(path)
+        return await self._request('GET', url)
+
+    async def post(self, path: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Make a POST request."""
+        url = self._build_url(path)
+        return await self._request('POST', url, data)
+
+    async def put(self, path: str, data: Dict[str, Any]) -> Dict[str, Any]:
+        """Make a PUT request."""
+        url = self._build_url(path)
+        return await self._request('PUT', url, data)
+
+    async def delete(self, path: str) -> Dict[str, Any]:
+        """Make a DELETE request."""
+        url = self._build_url(path)
+        return await self._request('DELETE', url)
+
+    def _build_url(self, path: str) -> str:
+        """Build the full URL."""
+        if path.startswith('http'):
+            return path
+        return f"{self.base_url}{path}"
+
+    async def _request(
+        self,
+        method: str,
+        url: str,
+        data: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        """Make an HTTP request."""
+        # Simulated request
+        await asyncio.sleep(0.01)
+        return {
+            "status": 200,
+            "method": method,
+            "url": url,
+            "data": data
+        }
+
+
+def create_service(config: Optional[ServiceConfig] = None) -> DataService:
+    """Factory function to create a data service."""
+    return DataService(config)
+
+
+def create_api_client(config: Optional[ServiceConfig] = None) -> ApiClient:
+    """Factory function to create an API client."""
+    return ApiClient(config or ServiceConfig())

package/test/fixtures/python/utils.py

@@ -0,0 +1,118 @@
+"""
+Utility functions for data manipulation.
+"""
+
+from typing import Any, Dict, List, TypeVar, Union
+
+
+T = TypeVar('T')
+
+
+def format_data(data: Any) -> Dict[str, Any]:
+    """Format data into a dictionary."""
+    if hasattr(data, '__dict__'):
+        return {k: v for k, v in data.__dict__.items() if not k.startswith('_')}
+    elif isinstance(data, dict):
+        return data.copy()
+    else:
+        return {"value": data}
+
+
+def validate_input(data: T) -> T:
+    """Validate input data."""
+    if data is None:
+        raise ValueError("Input cannot be None")
+    return data
+
+
+def deep_merge(base: Dict[str, Any], updates: Dict[str, Any]) -> Dict[str, Any]:
+    """Deep merge two dictionaries."""
+    result = base.copy()
+    for key, value in updates.items():
+        if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+            result[key] = deep_merge(result[key], value)
+        else:
+            result[key] = value
+    return result
+
+
+def flatten_list(nested: List[List[T]]) -> List[T]:
+    """Flatten a nested list."""
+    result = []
+    for item in nested:
+        if isinstance(item, list):
+            result.extend(flatten_list(item))
+        else:
+            result.append(item)
+    return result
+
+
+def chunk_list(items: List[T], size: int) -> List[List[T]]:
+    """Split a list into chunks of given size."""
+    return [items[i:i + size] for i in range(0, len(items), size)]
+
+
+def safe_get(obj: Dict[str, Any], path: str, default: Any = None) -> Any:
+    """Safely get a nested value from a dictionary."""
+    keys = path.split('.')
+    current = obj
+    for key in keys:
+        if isinstance(current, dict) and key in current:
+            current = current[key]
+        else:
+            return default
+    return current
+
+
+def transform_keys(data: Dict[str, Any], transformer: callable) -> Dict[str, Any]:
+    """Transform all keys in a dictionary."""
+    return {transformer(k): v for k, v in data.items()}
+
+
+def snake_to_camel(name: str) -> str:
+    """Convert snake_case to camelCase."""
+    components = name.split('_')
+    return components[0] + ''.join(x.title() for x in components[1:])
+
+
+def camel_to_snake(name: str) -> str:
+    """Convert camelCase to snake_case."""
+    result = []
+    for char in name:
+        if char.isupper():
+            result.append('_')
+            result.append(char.lower())
+        else:
+            result.append(char)
+    return ''.join(result).lstrip('_')
+
+
+class DataTransformer:
+    """Class for transforming data."""
+
+    def __init__(self):
+        self.transformations = []
+
+    def add_transformation(self, fn: callable) -> 'DataTransformer':
+        """Add a transformation function."""
+        self.transformations.append(fn)
+        return self
+
+    def transform(self, data: Any) -> Any:
+        """Apply all transformations."""
+        result = data
+        for fn in self.transformations:
+            result = fn(result)
+        return result
+
+    def clear(self) -> None:
+        """Clear all transformations."""
+        self.transformations = []
+
+
+# Helper function that uses other utilities
+def process_and_format(data: Any) -> Dict[str, Any]:
+    """Process data and format it."""
+    validated = validate_input(data)
+    formatted = format_data(validated)
+    return formatted

package/test/fixtures/rust/Cargo.toml

@@ -0,0 +1,3 @@
+[package]
+name = "rust-fixtures"
+version = "1.0.0"