Merge pull request #285 from Dictionarry-Hub/dev

Author: santiagosayshey

Dockerfile

@@ -1,13 +1,28 @@
 # Dockerfile
 FROM python:3.9-slim
 WORKDIR /app
-# Install git and gosu for user switching
-RUN apt-get update && apt-get install -y git gosu && rm -rf /var/lib/apt/lists/*
+# Install git, gosu, and PowerShell Core
+RUN apt-get update && apt-get install -y \
+    git \
+    gosu \
+    wget \
+    ca-certificates \
+    libicu-dev \
+    && wget -O /tmp/powershell.tar.gz https://github.com/PowerShell/PowerShell/releases/download/v7.4.0/powershell-7.4.0-linux-x64.tar.gz \
+    && mkdir -p /opt/microsoft/powershell/7 \
+    && tar zxf /tmp/powershell.tar.gz -C /opt/microsoft/powershell/7 \
+    && chmod +x /opt/microsoft/powershell/7/pwsh \
+    && ln -s /opt/microsoft/powershell/7/pwsh /usr/bin/pwsh \
+    && rm /tmp/powershell.tar.gz \
+    && rm -rf /var/lib/apt/lists/*
 # Copy pre-built files from dist directory
 COPY dist/backend/app ./app
+COPY dist/backend/scripts ./app/scripts
 COPY dist/static ./app/static
 COPY dist/requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
+# Ensure scripts are executable
+RUN chmod +x /app/scripts/*.ps1 || true
 # Copy and setup entrypoint script
 COPY entrypoint.sh /entrypoint.sh
 RUN chmod +x /entrypoint.sh

backend/Dockerfile

@@ -1,7 +1,21 @@
 FROM python:3.9
 WORKDIR /app
+# Install PowerShell Core
+RUN apt-get update && apt-get install -y \
+    wget \
+    ca-certificates \
+    libicu-dev \
+    && wget -O /tmp/powershell.tar.gz https://github.com/PowerShell/PowerShell/releases/download/v7.4.0/powershell-7.4.0-linux-x64.tar.gz \
+    && mkdir -p /opt/microsoft/powershell/7 \
+    && tar zxf /tmp/powershell.tar.gz -C /opt/microsoft/powershell/7 \
+    && chmod +x /opt/microsoft/powershell/7/pwsh \
+    && ln -s /opt/microsoft/powershell/7/pwsh /usr/bin/pwsh \
+    && rm /tmp/powershell.tar.gz \
+    && rm -rf /var/lib/apt/lists/*
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 COPY . .
+# Ensure scripts are executable
+RUN chmod +x /app/scripts/*.ps1 || true
 # Use gunicorn with 10-minute timeout
 CMD ["python", "-m", "app.main"]

backend/app/data/__init__.py

@@ -7,6 +7,7 @@
                     test_regex_pattern, test_format_conditions,
                     check_delete_constraints, filename_to_display)
 from ..db import add_format_to_renames, remove_format_from_renames, is_format_in_renames
+from .cache import data_cache
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.INFO)
@@ -16,43 +17,19 @@
 @bp.route('/<string:category>', methods=['GET'])
 def retrieve_all(category):
     try:
-        directory = get_category_directory(category)
-        files = [f for f in os.listdir(directory) if f.endswith('.yml')]
-        logger.debug(f"Found {len(files)} files in {category}")
-
-        if not files:
-            return jsonify([]), 200
-
-        result = []
-        errors = 0
-        for file_name in files:
-            file_path = os.path.join(directory, file_name)
-            try:
-                content = load_yaml_file(file_path)
-                # Add metadata for custom formats
-                if category == 'custom_format':
-                    content['metadata'] = {
-                        'includeInRename':
-                        is_format_in_renames(content['name'])
+        # Use cache instead of reading from disk
+        items = data_cache.get_all(category)
+        
+        # Add metadata for custom formats
+        if category == 'custom_format':
+            for item in items:
+                if 'content' in item and 'name' in item['content']:
+                    item['content']['metadata'] = {
+                        'includeInRename': is_format_in_renames(item['content']['name'])
                     }
-                result.append({
-                    "file_name":
-                    file_name,
-                    "content":
-                    content,
-                    "modified_date":
-                    get_file_modified_date(file_path)
-                })
-            except yaml.YAMLError:
-                errors += 1
-                result.append({
-                    "file_name": file_name,
-                    "error": "Failed to parse YAML"
-                })
-
-        logger.info(
-            f"Processed {len(files)} {category} files ({errors} errors)")
-        return jsonify(result), 200
+        
+        logger.info(f"Retrieved {len(items)} {category} items from cache")
+        return jsonify(items), 200
 
     except ValueError as ve:
         logger.error(ve)
@@ -127,6 +104,10 @@ def handle_item(category, name):
 
                 # Then delete the file
                 os.remove(file_path)
+                
+                # Update cache
+                data_cache.remove_item(category, file_name)
+                
                 return jsonify(
                     {"message": f"Successfully deleted {file_name}"}), 200
             except OSError as e:
@@ -226,32 +207,62 @@ def handle_item(category, name):
         return jsonify({"error": "An unexpected error occurred"}), 500
 
 
+@bp.route('/regex/verify', methods=['POST'])
+def verify_regex():
+    """Verify a regex pattern using .NET regex engine via PowerShell"""
+    try:
+        data = request.get_json()
+        if not data:
+            return jsonify({"error": "No JSON data provided"}), 400
+        
+        pattern = data.get('pattern')
+        if not pattern:
+            return jsonify({"error": "Pattern is required"}), 400
+        
+        from .utils import verify_dotnet_regex
+        
+        success, message = verify_dotnet_regex(pattern)
+        
+        if success:
+            return jsonify({"valid": True, "message": "Pattern is valid"}), 200
+        else:
+            return jsonify({"valid": False, "error": message}), 200
+    
+    except Exception as e:
+        logger.exception("Error verifying regex pattern")
+        return jsonify({"valid": False, "error": str(e)}), 500
+
+
 @bp.route('/<string:category>/test', methods=['POST'])
 def run_tests(category):
     logger.info(f"Received test request for category: {category}")
 
     try:
         data = request.get_json()
         if not data:
-            logger.warning("Rejected test request - no JSON data provided")
+            logger.warning("Test request rejected: no JSON data")
             return jsonify({"error": "No JSON data provided"}), 400
 
         tests = data.get('tests', [])
         if not tests:
-            logger.warning("Rejected test request - no test cases provided")
+            logger.warning("Test request rejected: no tests provided")
             return jsonify({"error":
                             "At least one test case is required"}), 400
 
         if category == 'regex_pattern':
             pattern = data.get('pattern')
-            logger.info(f"Processing regex test request - Pattern: {pattern}")
 
             if not pattern:
-                logger.warning("Rejected test request - missing pattern")
+                logger.warning("Test request rejected: missing pattern")
                 return jsonify({"error": "Pattern is required"}), 400
 
             success, message, updated_tests = test_regex_pattern(
                 pattern, tests)
+            
+            if success and updated_tests:
+                passed = sum(1 for t in updated_tests if t.get('passes'))
+                total = len(updated_tests)
+                logger.info(f"Tests completed: {passed}/{total} passed")
 
         elif category == 'custom_format':
             conditions = data.get('conditions', [])
@@ -274,10 +285,8 @@ def run_tests(category):
             return jsonify(
                 {"error": "Testing not supported for this category"}), 400
 
-        logger.info(f"Test execution completed - Success: {success}")
-
         if not success:
-            logger.warning(f"Test execution failed - {message}")
+            logger.error(f"Test execution failed: {message}")
             return jsonify({"success": False, "message": message}), 400
 
         return jsonify({"success": True, "tests": updated_tests}), 200

backend/app/data/cache.py

@@ -0,0 +1,117 @@
+import os
+import yaml
+import logging
+from typing import Dict, List, Any, Optional
+from datetime import datetime
+import threading
+from .utils import get_category_directory, get_file_modified_date, filename_to_display
+
+logger = logging.getLogger(__name__)
+
+class DataCache:
+    """In-memory cache for YAML data"""
+    
+    def __init__(self):
+        self._cache = {
+            'regex_pattern': {},
+            'custom_format': {},
+            'profile': {}
+        }
+        self._lock = threading.RLock()
+        self._initialized = False
+    
+    def initialize(self, force_reload=False):
+        """Load all data into memory on startup
+        
+        Args:
+            force_reload: If True, force a reload even if already initialized
+        """
+        with self._lock:
+            if self._initialized and not force_reload:
+                return
+            
+            logger.info("Initializing data cache..." if not force_reload else "Reloading data cache...")
+            for category in self._cache.keys():
+                self._load_category(category)
+            
+            self._initialized = True
+            logger.info("Data cache initialized successfully" if not force_reload else "Data cache reloaded successfully")
+    
+    def _load_category(self, category: str):
+        """Load all items from a category into cache"""
+        try:
+            directory = get_category_directory(category)
+            items = {}
+            
+            for filename in os.listdir(directory):
+                if not filename.endswith('.yml'):
+                    continue
+                
+                file_path = os.path.join(directory, filename)
+                try:
+                    with open(file_path, 'r') as f:
+                        content = yaml.safe_load(f)
+                        if content:
+                            # Store with metadata
+                            items[filename] = {
+                                'file_name': filename,
+                                'modified_date': get_file_modified_date(file_path),
+                                'content': content
+                            }
+                except Exception as e:
+                    logger.error(f"Error loading {file_path}: {e}")
+            
+            self._cache[category] = items
+            logger.info(f"Loaded {len(items)} items for category {category}")
+            
+        except Exception as e:
+            logger.error(f"Error loading category {category}: {e}")
+    
+    def get_all(self, category: str) -> List[Dict[str, Any]]:
+        """Get all items from a category"""
+        with self._lock:
+            if not self._initialized:
+                self.initialize()
+            
+            return list(self._cache.get(category, {}).values())
+    
+    def get_item(self, category: str, name: str) -> Optional[Dict[str, Any]]:
+        """Get a specific item"""
+        with self._lock:
+            if not self._initialized:
+                self.initialize()
+            
+            # Convert name to filename
+            filename = f"{name.replace('[', '(').replace(']', ')')}.yml"
+            return self._cache.get(category, {}).get(filename)
+    
+    def update_item(self, category: str, filename: str, content: Dict[str, Any]):
+        """Update an item in cache"""
+        with self._lock:
+            if category in self._cache:
+                file_path = os.path.join(get_category_directory(category), filename)
+                self._cache[category][filename] = {
+                    'file_name': filename,
+                    'modified_date': get_file_modified_date(file_path),
+                    'content': content
+                }
+                logger.debug(f"Updated cache for {category}/{filename}")
+    
+    def remove_item(self, category: str, filename: str):
+        """Remove an item from cache"""
+        with self._lock:
+            if category in self._cache and filename in self._cache[category]:
+                del self._cache[category][filename]
+                logger.debug(f"Removed from cache: {category}/{filename}")
+    
+    def rename_item(self, category: str, old_filename: str, new_filename: str):
+        """Rename an item in cache"""
+        with self._lock:
+            if category in self._cache and old_filename in self._cache[category]:
+                item = self._cache[category].pop(old_filename)
+                item['file_name'] = new_filename
+                self._cache[category][new_filename] = item
+                logger.debug(f"Renamed in cache: {category}/{old_filename} -> {new_filename}")
+
+# Global cache instance
+data_cache = DataCache()