je-editor 0.0.104__py3-none-any.whl → 0.0.228__py3-none-any.whl

je_editor/__init__.py

@@ -1,29 +1,34 @@
-# start editor
+from je_editor.pyside_ui.browser.main_browser_widget import MainBrowserWidget
+from je_editor.pyside_ui.code.code_process.code_exec import ExecManager
+from je_editor.pyside_ui.code.shell_process.shell_exec import ShellManager
+from je_editor.pyside_ui.code.syntax.python_syntax import PythonHighlighter
+from je_editor.pyside_ui.code.syntax.syntax_setting import syntax_extend_setting_dict, syntax_rule_setting_dict
+from je_editor.pyside_ui.main_ui.editor.editor_widget import EditorWidget
+from je_editor.pyside_ui.main_ui.editor.editor_widget_dock import FullEditorWidget
+from je_editor.pyside_ui.main_ui.main_editor import EDITOR_EXTEND_TAB
+from je_editor.pyside_ui.main_ui.main_editor import EditorMain
+from je_editor.pyside_ui.main_ui.save_settings.user_color_setting_file import user_setting_color_dict
+from je_editor.pyside_ui.main_ui.save_settings.user_setting_file import user_setting_dict
 from je_editor.start_editor import start_editor
-# Editor
-from je_editor.pyside_ui.main_ui.editor_main_ui.main_editor import EditorMain
-# Exceptions
+from je_editor.utils.exception.exceptions import JEditorCantFindLanguageException
+from je_editor.utils.exception.exceptions import JEditorContentFileException
 from je_editor.utils.exception.exceptions import JEditorException
 from je_editor.utils.exception.exceptions import JEditorExecException
+from je_editor.utils.exception.exceptions import JEditorJsonException
+from je_editor.utils.exception.exceptions import JEditorOpenFileException
 from je_editor.utils.exception.exceptions import JEditorRunOnShellException
 from je_editor.utils.exception.exceptions import JEditorSaveFileException
-from je_editor.utils.exception.exceptions import JEditorOpenFileException
-from je_editor.utils.exception.exceptions import JEditorContentFileException
-from je_editor.utils.exception.exceptions import JEditorCantFindLanguageException
-from je_editor.utils.exception.exceptions import JEditorJsonException
-# Color
-from je_editor.pyside_ui.colors.global_color import error_color
-from je_editor.pyside_ui.colors.global_color import output_color
-# Exec and shell
-from je_editor.pyside_ui.code_process.code_exec import exec_manage
-from je_editor.pyside_ui.shell_process.shell_exec import shell_manager
+from je_editor.utils.multi_language.english import english_word_dict
+from je_editor.utils.multi_language.multi_language_wrapper import language_wrapper
+from je_editor.utils.multi_language.traditional_chinese import traditional_chinese_word_dict
 
 __all__ = [
-    "start_editor", "EditorMain",
-    "JEditorException", "JEditorExecException",
-    "JEditorRunOnShellException", "JEditorSaveFileException",
-    "JEditorOpenFileException", "JEditorContentFileException",
-    "JEditorCantFindLanguageException", "JEditorJsonException",
-    "error_color", "output_color",
-    "exec_manage", "shell_manager"
+    "start_editor", "EditorMain", "EDITOR_EXTEND_TAB",
+    "JEditorException", "JEditorExecException", "FullEditorWidget",
+    "JEditorRunOnShellException", "JEditorSaveFileException", "syntax_rule_setting_dict",
+    "JEditorOpenFileException", "JEditorContentFileException", "syntax_extend_setting_dict",
+    "JEditorCantFindLanguageException", "JEditorJsonException", "PythonHighlighter",
+    "user_setting_dict", "user_setting_color_dict", "EditorWidget", "MainBrowserWidget",
+    "ExecManager", "ShellManager", "traditional_chinese_word_dict", "english_word_dict",
+    "language_wrapper"
 ]

je_editor/__main__.py

@@ -2,7 +2,7 @@ if __name__ == "__main__":
     # argparse
     import argparse
 
-    from je_editor.tkinter_ui.editor_main_ui.tkinter_editor import start_editor
+    from je_editor.start_editor import start_editor
 
     argparse_event_dict = {
         "start": start_editor,

je_editor/code_scan/ruff_thread.py

@@ -0,0 +1,58 @@
+import subprocess
+import threading
+import time
+from queue import Queue
+
+
+class RuffThread(threading.Thread):
+    """
+    A thread class to run Ruff (a Python linter/formatter) as a subprocess.
+    使用子執行緒執行 Ruff (Python 程式碼檢查/格式化工具)。
+    """
+
+    def __init__(self, ruff_commands: list, std_queue: Queue, stderr_queue: Queue):
+        """
+        Initialize the RuffThread.
+        初始化 RuffThread。
+
+        :param ruff_commands: list of commands to run Ruff, e.g. ["ruff", "check"]
+                              要執行的 Ruff 指令，例如 ["ruff", "check"]
+        :param std_queue: queue to store standard output
+                          用來存放標準輸出的佇列
+        :param stderr_queue: queue to store error output
+                             用來存放錯誤輸出的佇列
+        """
+        super().__init__()
+        if ruff_commands is None:
+            self.ruff_commands = ["ruff", "check"]
+        else:
+            self.ruff_commands = ruff_commands
+
+        self.ruff_process = None
+        self.std_queue = std_queue
+        self.stderr_queue = stderr_queue
+
+    def run(self):
+        """
+        Run the Ruff process in a separate thread.
+        在子執行緒中執行 Ruff 程式。
+        """
+        # 啟動子程序，捕捉 stdout 與 stderr
+        self.ruff_process = subprocess.Popen(
+            self.ruff_commands,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            bufsize=1
+        )
+
+        # 等待子程序結束
+        while self.ruff_process.poll() is None:
+            time.sleep(1)
+        else:
+            # 子程序結束後，讀取 stdout 與 stderr
+            for line in self.ruff_process.stdout:
+                self.std_queue.put(line.strip())
+
+            for line in self.ruff_process.stderr:
+                self.stderr_queue.put(line.strip())

je_editor/code_scan/watchdog_implement.py

@@ -0,0 +1,56 @@
+import time
+from queue import Queue
+from typing import Dict
+
+from watchdog.events import FileSystemEventHandler
+
+from je_editor.code_scan.ruff_thread import RuffThread
+
+
+class RuffPythonFileChangeHandler(FileSystemEventHandler):
+    """
+    File system event handler that runs Ruff when Python files are modified.
+    當 Python 檔案被修改時，自動觸發 Ruff 檢查。
+    """
+
+    def __init__(self, ruff_commands: list = None, debounce_interval: float = 1.0):
+        """
+        :param ruff_commands: Ruff command list, e.g. ["ruff", "check"]
+        :param debounce_interval: Minimum interval (seconds) between re-runs for the same file
+                                  同一檔案觸發 Ruff 的最小間隔秒數
+        """
+        super().__init__()
+        self.ruff_commands = ruff_commands or ["ruff", "check"]
+        self.stdout_queue: Queue = Queue()
+        self.stderr_queue: Queue = Queue()
+        self.ruff_threads_dict: Dict[str, RuffThread] = {}
+        self.last_run_time: Dict[str, float] = {}
+        self.debounce_interval = debounce_interval
+
+    def _start_new_thread(self, file_path: str):
+        """Helper to start a new Ruff thread for a given file."""
+        ruff_thread = RuffThread(self.ruff_commands, self.stdout_queue, self.stderr_queue)
+        self.ruff_threads_dict[file_path] = ruff_thread
+        self.last_run_time[file_path] = time.time()
+        ruff_thread.start()
+
+    def on_modified(self, event):
+        """Triggered when a file is modified."""
+        if event.is_directory:
+            return
+
+        if not event.src_path.endswith(".py"):
+            return
+
+        now = time.time()
+        last_time = self.last_run_time.get(event.src_path, 0)
+
+        # Debounce: skip if last run was too recent
+        if now - last_time < self.debounce_interval:
+            return
+
+        ruff_thread = self.ruff_threads_dict.get(event.src_path)
+
+        if ruff_thread is None or not ruff_thread.is_alive():
+            self._start_new_thread(event.src_path)
+        # else: thread still running, skip

je_editor/code_scan/watchdog_thread.py

@@ -0,0 +1,78 @@
+import sys
+import threading
+import time
+from pathlib import Path
+
+from watchdog.observers import Observer
+
+from je_editor.code_scan.watchdog_implement import RuffPythonFileChangeHandler
+
+
+class WatchdogThread(threading.Thread):
+    """
+    A thread that runs a watchdog observer to monitor file changes.
+    使用 watchdog 監控檔案變化的執行緒。
+    """
+
+    def __init__(self, check_path: str):
+        """
+        :param check_path: Path to monitor (directory or file)
+                           要監控的路徑（資料夾或檔案）
+        """
+        super().__init__(daemon=True)  # 設為 daemon，主程式結束時自動退出
+        self.check_path = Path(check_path).resolve()
+        self.ruff_handler = RuffPythonFileChangeHandler()
+        self.running = True
+        self.observer = Observer()
+
+    def run(self):
+        """Start the watchdog observer loop."""
+        if not self.check_path.exists():
+            print(f"[Error] Path does not exist: {self.check_path}", file=sys.stderr)
+            return
+
+        # 設定監控
+        self.observer.schedule(self.ruff_handler, str(self.check_path), recursive=True)
+        self.observer.start()
+        print(f"[Watchdog] Monitoring started on {self.check_path}")
+
+        try:
+            while self.running:
+                time.sleep(1)
+                # 這裡可以加上 queue 輸出處理
+                self._process_ruff_output()
+        except KeyboardInterrupt:
+            print("[Watchdog] Interrupted by user")
+        finally:
+            self.observer.stop()
+            self.observer.join()
+            print("[Watchdog] Monitoring stopped")
+
+    def stop(self):
+        """Stop the watchdog thread safely."""
+        self.running = False
+
+    def _process_ruff_output(self):
+        """Process stdout/stderr queues from Ruff threads."""
+        while not self.ruff_handler.stdout_queue.empty():
+            line = self.ruff_handler.stdout_queue.get()
+            print(f"[Ruff STDOUT] {line}")
+
+        while not self.ruff_handler.stderr_queue.empty():
+            line = self.ruff_handler.stderr_queue.get()
+            print(f"[Ruff STDERR] {line}", file=sys.stderr)
+
+
+if __name__ == '__main__':
+    # 預設監控當前目錄
+    path_to_watch = "."
+    watchdog_thread = WatchdogThread(path_to_watch)
+    watchdog_thread.start()
+
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        print("[Main] Stopping watchdog...")
+        watchdog_thread.stop()
+        watchdog_thread.join()

je_editor/git_client/commit_graph.py

@@ -0,0 +1,77 @@
+import logging
+from dataclasses import dataclass, field
+from typing import List, Dict, Any
+
+log = logging.getLogger(__name__)
+
+
+@dataclass
+class CommitNode:
+    commit_sha: str
+    author_name: str
+    commit_date: str
+    commit_message: str
+    parent_shas: List[str]
+    lane_index: int = -1  # assigned later
+
+
+@dataclass
+class CommitGraph:
+    nodes: List[CommitNode] = field(default_factory=list)
+    index: Dict[str, int] = field(default_factory=dict)  # sha -> row
+
+    def build(self, commits: List[Dict[str, Any]], refs: Dict[str, str] | None = None) -> None:
+        """
+        Build commit graph from topo-ordered commits.
+        從 topo-order 的 commits 建立 commit graph。
+        """
+        self.nodes = [
+            CommitNode(
+                commit_sha=commit["sha"],
+                author_name=commit["author"],
+                commit_date=commit["date"],
+                commit_message=commit["message"],
+                parent_shas=commit["parents"],
+            )
+            for commit in commits
+        ]
+        self.index = {node.commit_sha: index for index, node in enumerate(self.nodes)}
+        self._assign_lanes()
+
+    def _assign_lanes(self) -> None:
+        """
+        Assign lanes to commits, similar to `git log --graph`.
+        分配 lanes，模擬 `git log --graph` 的效果。
+        """
+        active: Dict[int, str] = {}  # lane -> sha
+        free_lanes: List[int] = []
+
+        for node in self.nodes:
+            # Step 1: 找到 lane
+            lane_found = next((lane for lane, sha in active.items() if sha == node.commit_sha), None)
+
+            if lane_found is not None:
+                node.lane_index = lane_found
+            elif free_lanes:
+                node.lane_index = free_lanes.pop(0)
+            else:
+                node.lane_index = 0 if not active else max(active.keys()) + 1
+
+            # Step 2: 更新 active
+            # 移除舊的 sha
+            active = {lane: sha for lane, sha in active.items() if sha != node.commit_sha}
+
+            # 父節點分配 lane
+            if node.parent_shas:
+                first_parent = node.parent_shas[0]
+                active[node.lane_index] = first_parent
+                for p in node.parent_shas[1:]:
+                    pl = free_lanes.pop(0) if free_lanes else (max(active.keys()) + 1)
+                    active[pl] = p
+
+            # Step 3: 更新 free_lanes
+            if active:
+                max_lane = max(active.keys())
+                used = set(active.keys())
+                all_lanes = set(range(max_lane + 1))
+                free_lanes = sorted(set(free_lanes).union(all_lanes - used))

je_editor/git_client/git_action.py

@@ -0,0 +1,175 @@
+import os
+from datetime import datetime
+
+from PySide6.QtCore import QThread, Signal
+from git import Repo, GitCommandError, InvalidGitRepositoryError, NoSuchPathError
+
+
+# Simple audit logger
+def audit_log(repo_path: str, action: str, detail: str, ok: bool, err: str = ""):
+    """
+    Append an audit log entry to 'audit.log' in the repo directory.
+    This is useful for compliance and traceability.
+    """
+    try:
+        path = os.path.join(repo_path if repo_path else ".", "audit.log")
+        with open(path, "a", encoding="utf-8") as f:
+            ts = datetime.now().isoformat(timespec="seconds")
+            f.write(f"{ts}\taction={action}\tok={ok}\tdetail={detail}\terr={err}\n")
+    except Exception:
+        pass  # Never let audit logging failure break the UI
+
+
+# Git service layer
+class GitService:
+    """
+    Encapsulates Git operations using GitPython.
+    Keeps UI logic separate from Git logic.
+    """
+
+    def __init__(self):
+        self.repo: Repo | None = None
+        self.repo_path: str | None = None
+
+    def open_repo(self, path: str):
+        try:
+            self.repo = Repo(path)
+            self.repo_path = path
+            audit_log(path, "open_repo", path, True)
+        except (InvalidGitRepositoryError, NoSuchPathError) as e:
+            audit_log(path, "open_repo", path, False, str(e))
+            raise
+
+    def list_branches(self):
+        self._ensure_repo()
+        branches = [head.name for head in self.repo.heads]
+        audit_log(self.repo_path, "list_branches", ",".join(branches), True)
+        return branches
+
+    def current_branch(self):
+        self._ensure_repo()
+        try:
+            return self.repo.active_branch.name
+        except TypeError:
+            return "(detached HEAD)"
+
+    def checkout(self, branch: str):
+        self._ensure_repo()
+        try:
+            self.repo.git.checkout(branch)
+            audit_log(self.repo_path, "checkout", branch, True)
+        except GitCommandError as e:
+            audit_log(self.repo_path, "checkout", branch, False, str(e))
+            raise
+
+    def list_commits(self, branch: str, max_count: int = 100):
+        self._ensure_repo()
+        commits = list(self.repo.iter_commits(branch, max_count=max_count))
+        data = [
+            {
+                "hexsha": c.hexsha,
+                "summary": c.summary,
+                "author": c.author.name if c.author else "",
+                "date": datetime.fromtimestamp(c.committed_date).isoformat(sep=" ", timespec="seconds"),
+            }
+            for c in commits
+        ]
+        audit_log(self.repo_path, "list_commits", f"{branch}:{len(data)}", True)
+        return data
+
+    def show_diff_of_commit(self, commit_sha: str) -> str:
+        self._ensure_repo()
+        commit = self.repo.commit(commit_sha)
+        parent = commit.parents[0] if commit.parents else None
+        if parent is None:
+            null_tree = self.repo.tree(NULL_TREE)
+            diffs = commit.diff(null_tree, create_patch=True)
+        else:
+            diffs = commit.diff(parent, create_patch=True)
+        text = []
+        for d in diffs:
+            try:
+                text.append(d.diff.decode("utf-8", errors="replace"))
+            except Exception:
+                pass
+        out = "".join(text) if text else "(No patch content)"
+        audit_log(self.repo_path, "show_diff", commit_sha, True)
+        return out
+
+    def stage_all(self):
+        self._ensure_repo()
+        try:
+            self.repo.git.add(all=True)
+            audit_log(self.repo_path, "stage_all", "git_client add -A", True)
+        except GitCommandError as e:
+            audit_log(self.repo_path, "stage_all", "git_client add -A", False, str(e))
+            raise
+
+    def commit(self, message: str):
+        self._ensure_repo()
+        if not message.strip():
+            raise ValueError("Commit message is empty.")
+        try:
+            self.repo.index.commit(message)
+            audit_log(self.repo_path, "commit", message, True)
+        except Exception as e:
+            audit_log(self.repo_path, "commit", message, False, str(e))
+            raise
+
+    def pull(self, remote: str = "origin", branch: str | None = None):
+        self._ensure_repo()
+        if branch is None:
+            branch = self.current_branch()
+        try:
+            res = self.repo.git.pull(remote, branch)
+            audit_log(self.repo_path, "pull", f"{remote}/{branch}", True)
+            return res
+        except GitCommandError as e:
+            audit_log(self.repo_path, "pull", f"{remote}/{branch}", False, str(e))
+            raise
+
+    def push(self, remote: str = "origin", branch: str | None = None):
+        self._ensure_repo()
+        if branch is None:
+            branch = self.current_branch()
+        try:
+            res = self.repo.git.push(remote, branch)
+            audit_log(self.repo_path, "push", f"{remote}/{branch}", True)
+            return res
+        except GitCommandError as e:
+            audit_log(self.repo_path, "push", f"{remote}/{branch}", False, str(e))
+            raise
+
+    def remotes(self):
+        self._ensure_repo()
+        return [r.name for r in self.repo.remotes]
+
+    def _ensure_repo(self):
+        if self.repo is None:
+            raise RuntimeError("Repository not opened.")
+
+
+# Null tree constant for initial commit diff
+NULL_TREE = "4b825dc642cb6eb9a060e54bf8d69288fbee4904"
+
+
+# Worker thread wrapper
+class GitWorker(QThread):
+    """
+    Runs a function in a separate thread to avoid blocking the UI.
+    Emits (result, error) when done.
+    """
+    done = Signal(object, object)
+
+    def __init__(self, fn, *args, **kwargs):
+        super().__init__()
+        self.fn = fn
+        self.args = args
+        self.kwargs = kwargs
+
+    def run(self):
+        try:
+            res = self.fn(*self.args, **self.kwargs)
+            self.done.emit(res, None)
+        except Exception as e:
+            self.done.emit(None, e)

je_editor/git_client/git_cli.py

@@ -0,0 +1,66 @@
+import logging
+import subprocess
+from pathlib import Path
+from typing import List, Dict
+
+log = logging.getLogger(__name__)
+
+
+class GitCLI:
+    def __init__(self, repo_path: Path):
+        self.repo_path = Path(repo_path)
+
+    def is_git_repo(self) -> bool:
+        return (self.repo_path / ".git").exists()
+
+    def _run(self, args: List[str]) -> str:
+        log.debug("git %s", " ".join(args))
+        res = subprocess.run(
+            ["git"] + args,
+            cwd=self.repo_path,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            encoding="utf-8",
+        )
+        if res.returncode != 0:
+            log.error("Git failed: %s", res.stderr.strip())
+            raise RuntimeError(res.stderr.strip())
+        return res.stdout
+
+    def get_all_refs(self) -> Dict[str, str]:
+        # returns refname -> commit hash
+        out = self._run(["show-ref", "--heads", "--tags"])
+        refs = {}
+        for line in out.splitlines():
+            if not line.strip():
+                continue
+            sha, ref = line.split(" ", 1)
+            refs[ref.strip()] = sha.strip()
+        return refs
+
+    def get_commits(self, max_count: int = 500) -> List[Dict]:
+        """
+        Return recent commits across all refs, with parents.
+        """
+        fmt = "%H%x01%P%x01%an%x01%ad%x01%s"
+        out = self._run([
+            "log", "--date=short", f"--format={fmt}", "--all",
+            f"--max-count={max_count}", "--topo-order"
+        ])
+        commits = []
+        for line in out.splitlines():
+            if not line.strip():
+                continue
+            parts = line.split("\x01")
+            if len(parts) != 5:
+                continue
+            sha, parents, author, date, msg = parts
+            commits.append({
+                "sha": sha,
+                "parents": [p for p in parents.strip().split() if p],
+                "author": author,
+                "date": date,
+                "message": msg,
+            })
+        return commits

je_editor/pyside_ui/browser/browser_download_window.py

@@ -0,0 +1,75 @@
+from PySide6.QtCore import Qt
+from PySide6.QtWebEngineCore import QWebEngineDownloadRequest
+from PySide6.QtWidgets import QWidget, QBoxLayout, QPlainTextEdit
+
+from je_editor.utils.logging.loggin_instance import jeditor_logger
+from je_editor.utils.multi_language.multi_language_wrapper import language_wrapper
+
+
+class BrowserDownloadWindow(QWidget):
+    """
+    A window widget to display details of a browser download.
+    瀏覽器下載視窗，用來顯示下載的詳細資訊。
+    """
+
+    def __init__(self, download_instance: QWebEngineDownloadRequest):
+        """
+        Initialize the download window with a given QWebEngineDownloadRequest.
+        使用指定的 QWebEngineDownloadRequest 初始化下載視窗。
+        """
+        super().__init__()
+        # 記錄初始化訊息到 logger
+        jeditor_logger.info("Init BrowserDownloadWindow "
+                            f"download_instance: {download_instance}")
+
+        # 設定視窗屬性：當視窗關閉時自動刪除
+        self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose)
+
+        # 建立垂直方向的 BoxLayout
+        self.box_layout = QBoxLayout(QBoxLayout.Direction.TopToBottom)
+
+        # 建立文字框來顯示下載細節，並設為唯讀
+        self.show_download_detail_plaintext = QPlainTextEdit()
+        self.show_download_detail_plaintext.setReadOnly(True)
+
+        # 設定視窗標題，支援多語言
+        self.setWindowTitle(language_wrapper.language_word_dict.get("browser_download_detail"))
+
+        # 儲存下載實例
+        self.download_instance = download_instance
+
+        # 綁定下載事件到對應的處理函式
+        self.download_instance.isFinishedChanged.connect(self.print_finish)  # 當下載完成時
+        self.download_instance.interruptReasonChanged.connect(self.print_interrupt)  # 當下載被中斷時
+        self.download_instance.stateChanged.connect(self.print_state)  # 當下載狀態改變時
+
+        # 接受下載請求，開始下載
+        self.download_instance.accept()
+
+        # 將文字框加入版面配置
+        self.box_layout.addWidget(self.show_download_detail_plaintext)
+        self.setLayout(self.box_layout)
+
+    def print_finish(self):
+        """
+        Slot function triggered when download finishes.
+        當下載完成時觸發，將完成狀態輸出到 logger 與文字框。
+        """
+        jeditor_logger.info("BrowserDownloadWindow Print Download is Finished")
+        self.show_download_detail_plaintext.appendPlainText(str(self.download_instance.isFinished()))
+
+    def print_interrupt(self):
+        """
+        Slot function triggered when download is interrupted.
+        當下載被中斷時觸發，將中斷原因輸出到 logger 與文字框。
+        """
+        jeditor_logger.info("BrowserDownloadWindow Print interruptReason")
+        self.show_download_detail_plaintext.appendPlainText(str(self.download_instance.interruptReason()))
+
+    def print_state(self):
+        """
+        Slot function triggered when download state changes.
+        當下載狀態改變時觸發，將狀態輸出到 logger 與文字框。
+        """
+        jeditor_logger.info("BrowserDownloadWindow Print State")
+        self.show_download_detail_plaintext.appendPlainText(str(self.download_instance.state()))