pomera-ai-commander 0.1.0

package/tools/string_escape_tool.py

@@ -0,0 +1,393 @@
+"""
+String Escape/Unescape Tool Module - String encoding utilities
+
+This module provides string escape and unescape functionality for various formats
+for the Pomera AI Commander application.
+
+Features:
+- JSON Escape/Unescape
+- HTML Escape/Unescape
+- URL Encode/Decode
+- XML Escape/Unescape
+- JavaScript Escape/Unescape
+- SQL Escape
+"""
+
+import tkinter as tk
+from tkinter import ttk
+import html
+import json
+import re
+from urllib.parse import quote, unquote, quote_plus, unquote_plus
+
+
+class StringEscapeProcessor:
+    """String escape processor with multiple format support."""
+    
+    @staticmethod
+    def json_escape(text):
+        """Escape string for JSON."""
+        return json.dumps(text)[1:-1]  # Remove surrounding quotes
+    
+    @staticmethod
+    def json_unescape(text):
+        """Unescape JSON string."""
+        try:
+            return json.loads(f'"{text}"')
+        except json.JSONDecodeError:
+            return f"Error: Invalid JSON escape sequence"
+    
+    @staticmethod
+    def html_escape(text):
+        """Escape string for HTML."""
+        return html.escape(text, quote=True)
+    
+    @staticmethod
+    def html_unescape(text):
+        """Unescape HTML entities."""
+        return html.unescape(text)
+    
+    @staticmethod
+    def url_encode(text, plus_spaces=False):
+        """URL encode string."""
+        if plus_spaces:
+            return quote_plus(text)
+        return quote(text, safe='')
+    
+    @staticmethod
+    def url_decode(text, plus_spaces=False):
+        """URL decode string."""
+        try:
+            if plus_spaces:
+                return unquote_plus(text)
+            return unquote(text)
+        except Exception as e:
+            return f"Error: {str(e)}"
+    
+    @staticmethod
+    def xml_escape(text):
+        """Escape string for XML."""
+        replacements = [
+            ('&', '&'),
+            ('<', '&lt;'),
+            ('>', '&gt;'),
+            ('"', '&quot;'),
+            ("'", '&apos;'),
+        ]
+        result = text
+        for char, entity in replacements:
+            result = result.replace(char, entity)
+        return result
+    
+    @staticmethod
+    def xml_unescape(text):
+        """Unescape XML entities."""
+        replacements = [
+            ('&amp;', '&'),
+            ('&lt;', '<'),
+            ('&gt;', '>'),
+            ('&quot;', '"'),
+            ('&apos;', "'"),
+        ]
+        result = text
+        for entity, char in replacements:
+            result = result.replace(entity, char)
+        # Handle numeric entities
+        result = re.sub(r'&#(\d+);', lambda m: chr(int(m.group(1))), result)
+        result = re.sub(r'&#x([0-9a-fA-F]+);', lambda m: chr(int(m.group(1), 16)), result)
+        return result
+    
+    @staticmethod
+    def javascript_escape(text):
+        """Escape string for JavaScript."""
+        replacements = [
+            ('\\', '\\\\'),
+            ("'", "\\'"),
+            ('"', '\\"'),
+            ('\n', '\\n'),
+            ('\r', '\\r'),
+            ('\t', '\\t'),
+            ('\b', '\\b'),
+            ('\f', '\\f'),
+        ]
+        result = text
+        for char, escaped in replacements:
+            result = result.replace(char, escaped)
+        return result
+    
+    @staticmethod
+    def javascript_unescape(text):
+        """Unescape JavaScript string."""
+        replacements = [
+            ('\\n', '\n'),
+            ('\\r', '\r'),
+            ('\\t', '\t'),
+            ('\\b', '\b'),
+            ('\\f', '\f'),
+            ('\\"', '"'),
+            ("\\'", "'"),
+            ('\\\\', '\\'),
+        ]
+        result = text
+        for escaped, char in replacements:
+            result = result.replace(escaped, char)
+        # Handle unicode escapes
+        result = re.sub(r'\\u([0-9a-fA-F]{4})', lambda m: chr(int(m.group(1), 16)), result)
+        return result
+    
+    @staticmethod
+    def sql_escape(text):
+        """Escape string for SQL (single quotes)."""
+        return text.replace("'", "''")
+    
+    @staticmethod
+    def sql_unescape(text):
+        """Unescape SQL string."""
+        return text.replace("''", "'")
+    
+    @staticmethod
+    def process_text(input_text, format_type, mode, settings=None):
+        """Process text using the specified format and mode."""
+        settings = settings or {}
+        
+        if format_type == "json":
+            if mode == "escape":
+                return StringEscapeProcessor.json_escape(input_text)
+            else:
+                return StringEscapeProcessor.json_unescape(input_text)
+        
+        elif format_type == "html":
+            if mode == "escape":
+                return StringEscapeProcessor.html_escape(input_text)
+            else:
+                return StringEscapeProcessor.html_unescape(input_text)
+        
+        elif format_type == "url":
+            plus_spaces = settings.get("plus_spaces", False)
+            if mode == "escape":
+                return StringEscapeProcessor.url_encode(input_text, plus_spaces)
+            else:
+                return StringEscapeProcessor.url_decode(input_text, plus_spaces)
+        
+        elif format_type == "xml":
+            if mode == "escape":
+                return StringEscapeProcessor.xml_escape(input_text)
+            else:
+                return StringEscapeProcessor.xml_unescape(input_text)
+        
+        elif format_type == "javascript":
+            if mode == "escape":
+                return StringEscapeProcessor.javascript_escape(input_text)
+            else:
+                return StringEscapeProcessor.javascript_unescape(input_text)
+        
+        elif format_type == "sql":
+            if mode == "escape":
+                return StringEscapeProcessor.sql_escape(input_text)
+            else:
+                return StringEscapeProcessor.sql_unescape(input_text)
+        
+        else:
+            return f"Unknown format: {format_type}"
+
+
+class StringEscapeWidget(ttk.Frame):
+    """Widget for string escape tool."""
+    
+    def __init__(self, parent, app):
+        super().__init__(parent)
+        self.app = app
+        self.processor = StringEscapeProcessor()
+        
+        self.format_type = tk.StringVar(value="json")
+        self.mode = tk.StringVar(value="escape")
+        self.plus_spaces = tk.BooleanVar(value=False)
+        
+        self.create_widgets()
+        self.load_settings()
+    
+    def create_widgets(self):
+        """Creates the widget interface."""
+        # Format selection
+        format_frame = ttk.LabelFrame(self, text="Format", padding=10)
+        format_frame.pack(fill=tk.X, padx=5, pady=5)
+        
+        formats = [
+            ("JSON", "json"),
+            ("HTML", "html"),
+            ("URL", "url"),
+            ("XML", "xml"),
+            ("JavaScript", "javascript"),
+            ("SQL", "sql"),
+        ]
+        
+        for i, (text, value) in enumerate(formats):
+            ttk.Radiobutton(format_frame, text=text, 
+                           variable=self.format_type, value=value,
+                           command=self.on_setting_change).grid(row=i//3, column=i%3, sticky=tk.W, padx=5, pady=2)
+        
+        # Mode selection
+        mode_frame = ttk.LabelFrame(self, text="Mode", padding=10)
+        mode_frame.pack(fill=tk.X, padx=5, pady=5)
+        
+        ttk.Radiobutton(mode_frame, text="Escape", 
+                       variable=self.mode, value="escape",
+                       command=self.on_setting_change).pack(side=tk.LEFT, padx=10)
+        ttk.Radiobutton(mode_frame, text="Unescape", 
+                       variable=self.mode, value="unescape",
+                       command=self.on_setting_change).pack(side=tk.LEFT, padx=10)
+        
+        # URL-specific options
+        self.url_options_frame = ttk.LabelFrame(self, text="URL Options", padding=10)
+        self.url_options_frame.pack(fill=tk.X, padx=5, pady=5)
+        
+        ttk.Checkbutton(self.url_options_frame, text="Use + for spaces (form encoding)", 
+                       variable=self.plus_spaces,
+                       command=self.on_setting_change).pack(anchor=tk.W)
+        
+        # Process button
+        ttk.Button(self, text="Process", 
+                  command=self.process).pack(pady=10)
+        
+        # Update URL options visibility
+        self.update_url_options()
+    
+    def update_url_options(self):
+        """Show/hide URL options based on format selection."""
+        if self.format_type.get() == "url":
+            self.url_options_frame.pack(fill=tk.X, padx=5, pady=5)
+        else:
+            self.url_options_frame.pack_forget()
+    
+    def load_settings(self):
+        """Load settings from the application."""
+        settings = self.app.settings.get("tool_settings", {}).get("String Escape Tool", {})
+        
+        self.format_type.set(settings.get("format", "json"))
+        self.mode.set(settings.get("mode", "escape"))
+        self.plus_spaces.set(settings.get("plus_spaces", False))
+        self.update_url_options()
+    
+    def save_settings(self):
+        """Save current settings to the application."""
+        if "String Escape Tool" not in self.app.settings["tool_settings"]:
+            self.app.settings["tool_settings"]["String Escape Tool"] = {}
+        
+        self.app.settings["tool_settings"]["String Escape Tool"].update({
+            "format": self.format_type.get(),
+            "mode": self.mode.get(),
+            "plus_spaces": self.plus_spaces.get()
+        })
+        
+        self.app.save_settings()
+    
+    def on_setting_change(self, *args):
+        """Handle setting changes."""
+        self.update_url_options()
+        self.save_settings()
+    
+    def process(self):
+        """Process the input text."""
+        active_input_tab = self.app.input_tabs[self.app.input_notebook.index(self.app.input_notebook.select())]
+        input_text = active_input_tab.text.get("1.0", tk.END).rstrip('\n')
+        
+        if not input_text:
+            return
+        
+        settings = {"plus_spaces": self.plus_spaces.get()}
+        result = StringEscapeProcessor.process_text(
+            input_text,
+            self.format_type.get(),
+            self.mode.get(),
+            settings
+        )
+        
+        active_output_tab = self.app.output_tabs[self.app.output_notebook.index(self.app.output_notebook.select())]
+        active_output_tab.text.config(state="normal")
+        active_output_tab.text.delete("1.0", tk.END)
+        active_output_tab.text.insert("1.0", result)
+        active_output_tab.text.config(state="disabled")
+        
+        self.app.update_all_stats()
+
+
+class StringEscapeTool:
+    """Main class for String Escape Tool integration."""
+    
+    def __init__(self):
+        self.processor = StringEscapeProcessor()
+    
+    def create_widget(self, parent, app):
+        """Create and return the String Escape Tool widget."""
+        return StringEscapeWidget(parent, app)
+    
+    def get_default_settings(self):
+        """Return default settings for String Escape Tool."""
+        return {
+            "format": "json",
+            "mode": "escape",
+            "plus_spaces": False
+        }
+    
+    def process_text(self, input_text, format_type, mode, settings=None):
+        """Process text using the specified format and mode."""
+        return StringEscapeProcessor.process_text(input_text, format_type, mode, settings)
+
+
+# BaseTool-compatible wrapper
+try:
+    from tools.base_tool import ToolWithOptions
+    from typing import Dict, Any
+    
+    class StringEscapeToolV2(ToolWithOptions):
+        """
+        BaseTool-compatible version of StringEscapeTool.
+        """
+        
+        TOOL_NAME = "String Escape Tool"
+        TOOL_DESCRIPTION = "Escape/unescape strings for JSON, HTML, URL, XML"
+        TOOL_VERSION = "2.0.0"
+        
+        OPTIONS = [
+            ("JSON Escape", "json_escape"),
+            ("JSON Unescape", "json_unescape"),
+            ("HTML Escape", "html_escape"),
+            ("HTML Unescape", "html_unescape"),
+            ("URL Encode", "url_encode"),
+            ("URL Decode", "url_decode"),
+            ("XML Escape", "xml_escape"),
+            ("XML Unescape", "xml_unescape"),
+        ]
+        OPTIONS_LABEL = "Operation"
+        USE_DROPDOWN = True
+        DEFAULT_OPTION = "json_escape"
+        
+        def __init__(self):
+            super().__init__()
+            self._processor = StringEscapeProcessor()
+        
+        def process_text(self, input_text: str, settings: Dict[str, Any]) -> str:
+            """Process text using the specified escape operation."""
+            mode = settings.get("mode", "json_escape")
+            
+            if mode == "json_escape":
+                return StringEscapeProcessor.json_escape(input_text)
+            elif mode == "json_unescape":
+                return StringEscapeProcessor.json_unescape(input_text)
+            elif mode == "html_escape":
+                return StringEscapeProcessor.html_escape(input_text)
+            elif mode == "html_unescape":
+                return StringEscapeProcessor.html_unescape(input_text)
+            elif mode == "url_encode":
+                return StringEscapeProcessor.url_encode(input_text)
+            elif mode == "url_decode":
+                return StringEscapeProcessor.url_decode(input_text)
+            elif mode == "xml_escape":
+                return StringEscapeProcessor.xml_escape(input_text)
+            elif mode == "xml_unescape":
+                return StringEscapeProcessor.xml_unescape(input_text)
+            else:
+                return input_text
+
+except ImportError:
+    pass